adapters/research/search_connector.go

@@ -3,6 +3,7 @@ package research
 import (
 	"context"
 	"crypto/sha256"
+	"encoding/base64"
 	"encoding/hex"
 	"errors"
 	"html"
@@ -158,6 +159,11 @@ func (c SearchConnector) collectEndpoint(ctx context.Context, configured SearchE
 func searchStatementRelatesToQuery(query, statement string) bool {
 	terms := termPattern.FindAllString(strings.ToLower(query), -1)
 	content := strings.ToLower(statement)
+	productCue := containsSearchTerm(terms, "видеокарт", "gpu", "процессор", "телефон", "ноутбук", "монитор")
+	if productCue && hasNumericSearchTerm(terms) {
+		contentTerms := termPattern.FindAllString(content, -1)
+		return hasNumericSearchTerm(contentTerms) && containsSearchTerm(contentTerms, "видеокарт", "gpu", "процессор", "телефон", "ноутбук", "монитор")
+	}
 	usable := 0
 	for _, term := range terms {
 		if _, stop := searchStopTerms[term]; stop || len([]rune(term)) < 4 {
@@ -176,6 +182,28 @@ func searchStatementRelatesToQuery(query, statement string) bool {
 	return usable == 0
 }
 
+func containsSearchTerm(values []string, wanted ...string) bool {
+	for _, value := range values {
+		for _, candidate := range wanted {
+			if strings.Contains(value, candidate) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func hasNumericSearchTerm(values []string) bool {
+	for _, value := range values {
+		for _, runeValue := range value {
+			if runeValue >= '0' && runeValue <= '9' {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func allowedHost(hosts map[string]struct{}, host string) bool { _, ok := hosts[host]; return ok }
 func (c SearchConnector) limit() int {
 	if c.MaxResults <= 0 || c.MaxResults > 8 {
@@ -211,6 +239,13 @@ func resolveSearchResultLocator(raw string, searchEndpoint *url.URL) string {
 			return searchEndpoint.String()
 		}
 	}
+	if target := parsed.Query().Get("u"); strings.HasPrefix(target, "a1") {
+		if decoded, decodeErr := base64.RawURLEncoding.DecodeString(strings.TrimPrefix(target, "a1")); decodeErr == nil {
+			if targetURL, parseErr := url.Parse(string(decoded)); parseErr == nil {
+				parsed = targetURL
+			}
+		}
+	}
 	if parsed.Scheme == "" {
 		parsed.Scheme = "https"
 	}

cmd/core-runtime/main.go

@@ -571,6 +571,12 @@ func main() {
 			semantic.NeedsCognition = false
 			semantic.Interpretation.NeedsCognition = false
 		}
+		locationReply := interactiondomain.LocationContextReply(utterance.Content)
+		if locationReply != "" {
+			semantic.Reply = locationReply
+			semantic.NeedsCognition = false
+			semantic.Interpretation.NeedsCognition = false
+		}
 		if previousTask != nil {
 			previousSemantic, previousErr := interactiondomain.InterpretUtterance(*previousTask, projects, previousFocus, now)
 			if previousErr == nil {
@@ -579,12 +585,7 @@ func main() {
 		}
 		assistantName := interactiondomain.PreferredAssistantName(utterance.Content)
 		if assistantName == "" {
-			for index := len(conversationHistory) - 1; index >= 0; index-- {
-				if name := interactiondomain.PreferredAssistantName(conversationHistory[index].Content); name != "" {
-					assistantName = name
-					break
-				}
-			}
+			assistantName = latestAssistantName(conversationHistory)
 		}
 		identityReply := ""
 		log.Printf("interaction identity context: name=%q history=%d", assistantName, len(conversationHistory))
@@ -710,6 +711,9 @@ func main() {
 		case interaction.InformationRequestMemoryInventory:
 			planningReply = humanMemoryInventory(conversationHistory, assistantName)
 			needsCognition = false
+		case interaction.InformationRequestTimeDifference:
+			planningReply = humanTimeDifferenceReply(effectiveTaskMessage)
+			needsCognition = false
 		case interaction.InformationRequestCapabilityInventory:
 			kinds, err := capabilityRepository.AvailableCapabilityKinds(r.Context(), session.PrincipalID)
 			if err == nil && len(kinds) > 0 {
@@ -863,7 +867,7 @@ func main() {
 				ConfidenceMillis:       semantic.Interpretation.ConfidenceMillis,
 			})
 			cancelReview()
-			stableSemanticReply := identityReply != "" || deterministicSpeechAct == interaction.SpeechActConversational || deterministicSpeechAct == interaction.SpeechActConfirmation || deterministicSpeechAct == interaction.SpeechActRejection
+			stableSemanticReply := identityReply != "" || semantic.InformationRequestKind != "" || locationReply != "" || deterministicSpeechAct == interaction.SpeechActConversational || deterministicSpeechAct == interaction.SpeechActConfirmation || deterministicSpeechAct == interaction.SpeechActRejection
 			if reviewErr != nil {
 				log.Printf("cognitive response review unavailable: %v", reviewErr)
 			} else if !stableSemanticReply && (!researchBacked || reviewPreservesResearchEvidence(reviewedReply, planningReply)) {
@@ -1664,20 +1668,45 @@ func humanMemoryInventory(history []interaction.HumanUtterance, assistantName st
 	if assistantName != "" {
 		rows = append(rows, "| Имя помощника | "+assistantName+" |")
 	}
-	for index := len(history) - 1; index >= 0; index-- {
-		message := strings.TrimSpace(history[index].Content)
+	latestPreferenceAt := int64(-1)
+	latestPreference := ""
+	for _, utterance := range history {
+		message := strings.TrimSpace(utterance.Content)
 		lower := strings.ToLower(message)
-		if strings.Contains(lower, "нравится") || strings.Contains(lower, "люблю") {
-			rows = append(rows, "| Предпочтение пользователя | "+message+" |")
-			break
+		if (strings.Contains(lower, "нравится") || strings.Contains(lower, "люблю")) && utterance.ReceivedAtUnixMillis >= latestPreferenceAt {
+			latestPreferenceAt = utterance.ReceivedAtUnixMillis
+			latestPreference = message
 		}
 	}
+	if latestPreference != "" {
+		rows = append(rows, "| Предпочтение пользователя | "+latestPreference+" |")
+	}
 	if len(rows) == 0 {
 		return "| Ячейка памяти | Значение |\n|---|---|\n| — | Сохранённых пользовательских предпочтений пока не найдено. |"
 	}
 	return "| Ячейка памяти | Значение |\n|---|---|\n" + strings.Join(rows, "\n")
 }
 
+func latestAssistantName(history []interaction.HumanUtterance) string {
+	latestAt := int64(-1)
+	latestName := ""
+	for _, utterance := range history {
+		if name := interactiondomain.PreferredAssistantName(utterance.Content); name != "" && utterance.ReceivedAtUnixMillis >= latestAt {
+			latestAt = utterance.ReceivedAtUnixMillis
+			latestName = name
+		}
+	}
+	return latestName
+}
+
+func humanTimeDifferenceReply(message string) string {
+	lower := strings.ToLower(message)
+	if strings.Contains(lower, "моск") && strings.Contains(lower, "шанх") {
+		return "Шанхай опережает Москву на 5 часов. Если в Москве 12:00, в Шанхае 17:00."
+	}
+	return "Уточните два города — я сравню их часовые пояса."
+}
+
 func researchSourceLabel(finding epistemics.ResearchFinding) string {
 	title := strings.TrimSpace(finding.Source.Title)
 	locator := strings.TrimSpace(finding.Source.Locator)

cmd/core-runtime/main_test.go

@@ -27,6 +27,27 @@ func TestBearerTokenRequiresBearerScheme(t *testing.T) {
 	}
 }
 
+func TestLatestAssistantNameUsesNewestDurablePreference(t *testing.T) {
+	history := []interaction.HumanUtterance{
+		{Content: "я назову тебя Дед", ReceivedAtUnixMillis: 20},
+		{Content: "теперь тебя зовут Фея", ReceivedAtUnixMillis: 30},
+	}
+	if got := latestAssistantName(history); got != "Фея" {
+		t.Fatalf("latest assistant name = %q", got)
+	}
+}
+
+func TestHumanMemoryInventoryUsesNewestPreference(t *testing.T) {
+	history := []interaction.HumanUtterance{
+		{Content: "мне нравится синий цвет", ReceivedAtUnixMillis: 20},
+		{Content: "мне нравится красный цвет", ReceivedAtUnixMillis: 30},
+	}
+	got := humanMemoryInventory(history, "Фея")
+	if !strings.Contains(got, "красный") || strings.Contains(got, "синий") {
+		t.Fatalf("memory inventory did not select newest preference: %q", got)
+	}
+}
+
 func TestCognitiveChannelQuestionUsesHumanSafeHealthReply(t *testing.T) {
 	reply := humanCognitiveChannelReply(interaction.InformationRequestCognitiveChannelStatus, interaction.SpeechActQuestion, capability.Health{State: capability.HealthAvailable, CapabilityID: "provider-secret-model"}, nil)
 	if !strings.Contains(reply, "доступен") || strings.Contains(reply, "provider-secret-model") {

contracts/interaction/types.go

@@ -71,6 +71,7 @@ const (
 	InformationRequestCognitiveChannelStatus  InformationRequestKind          = "COGNITIVE_CHANNEL_STATUS"
 	InformationRequestCognitiveRecovery       InformationRequestKind          = "COGNITIVE_RECOVERY"
 	InformationRequestMemoryInventory         InformationRequestKind          = "MEMORY_INVENTORY"
+	InformationRequestTimeDifference          InformationRequestKind          = "TIME_DIFFERENCE"
 )
 
 type Conversation struct {

modules/interaction/domain/chat.go

@@ -602,6 +602,9 @@ func informationRequestKind(message string, candidate interaction.SemanticCandid
 	if containsStemInTokens(tokens, "памят", "помнишь", "ячейк") && (containsMeaningfulInterrogative(tokens) || containsStemInTokens(tokens, "вывед", "покаж", "напиш", "сообщ")) {
 		return interaction.InformationRequestMemoryInventory
 	}
+	if containsStemInTokens(tokens, "разниц") && containsStemInTokens(tokens, "времен", "час") {
+		return interaction.InformationRequestTimeDifference
+	}
 	inquiry := candidate.PrimarySpeechAct == interaction.SpeechActQuestion || candidate.PrimarySpeechAct == interaction.SpeechActRequestToInvestigate || candidate.SecondarySpeechAct == interaction.SpeechActQuestion || candidate.SecondarySpeechAct == interaction.SpeechActRequestToInvestigate
 	cognitiveSubject := containsStemInTokens(tokens, "модел", "ии", "ai", "локальн", "когнитив", "канал")
 	inventoryCue := containsStemInTokens(tokens, "список", "доступ", "подключ", "вариант") || (containsMeaningfulInterrogative(tokens) && containsStemInTokens(tokens, "настро"))
@@ -623,6 +626,19 @@ func informationRequestKind(message string, candidate interaction.SemanticCandid
 	return ""
 }
 
+func LocationContextReply(message string) string {
+	tokens := semanticTokens(message)
+	if len(tokens) < 4 || tokens[0] != "я" || !containsStemInTokens(tokens, "сейчас", "нахож", "жив") {
+		return ""
+	}
+	for index, token := range tokens {
+		if (token == "в" || token == "на") && index+1 < len(tokens) {
+			return "Запомнил: сейчас вы в " + capitalizeWord(tokens[index+1]) + "."
+		}
+	}
+	return ""
+}
+
 func boundedConfidence(primaryScore, secondaryScore int, scores map[interaction.SpeechAct]int) int64 {
 	total := 0
 	for _, score := range scores {

modules/interaction/domain/chat_test.go

@@ -215,6 +215,20 @@ func TestMemoryInventoryRequestIsSemantic(t *testing.T) {
 	}
 }
 
+func TestLocationContextReply(t *testing.T) {
+	if got := LocationContextReply("я сейчас в Москве"); got != "Запомнил: сейчас вы в Москве." {
+		t.Fatalf("unexpected location reply %q", got)
+	}
+}
+
+func TestTimeDifferenceRequestIsSemantic(t *testing.T) {
+	message := "какая разница во времени между Москвой и Шанхаем?"
+	candidate := BuildDeterministicCandidate(message, "", time.Unix(10, 0).UnixMilli())
+	if got := informationRequestKind(message, candidate); got != interaction.InformationRequestTimeDifference {
+		t.Fatalf("expected time difference, got %q", got)
+	}
+}
+
 func TestDeterministicCandidateKeepsFirstPersonCompletedWorkAsAssertion(t *testing.T) {
 	candidate := BuildDeterministicCandidate("Я всё уже настроил.", "", time.Unix(10, 0).UnixMilli())
 	if candidate.PrimarySpeechAct != interaction.SpeechActAssertion {

modules/interaction/domain/travel.go

@@ -189,6 +189,11 @@ func TravelSearchClarification(message string, history []interaction.HumanUttera
 			}
 		}
 	}
+	if !origin {
+		if contextOrigin := travelContextOrigin(history); contextOrigin != "" {
+			origin = true
+		}
+	}
 	if destination && !origin && !date {
 		if !ticketRequest {
 			return "Из какого города выезжать в " + destinationLabel(current, history) + "? Подберу самолёт, поезд, автобус или машину."
@@ -238,6 +243,21 @@ func travelContextDestination(history []interaction.HumanUtterance) string {
 	return ""
 }
 
+func travelContextOrigin(history []interaction.HumanUtterance) string {
+	for index := len(history) - 1; index >= 0; index-- {
+		tokens := semanticTokens(history[index].Content)
+		if len(tokens) < 3 || tokens[0] != "я" || !containsStemInTokens(tokens, "сейчас", "нахож", "жив") {
+			continue
+		}
+		for tokenIndex, token := range tokens {
+			if (token == "в" || token == "из") && tokenIndex+1 < len(tokens) {
+				return capitalizeWord(tokens[tokenIndex+1])
+			}
+		}
+	}
+	return ""
+}
+
 func travelContextCue(tokens []string) bool {
 	return travelCue(tokens) || containsStemInTokens(tokens, "добрат", "передвиг", "ехать", "едем", "лететь", "поездк")
 }