pulseed 0.6.5 → 0.6.6

package/dist/interface/chat/chat-runner.js

@@ -1,10 +1,10 @@
 // ─── ChatRunner ───
 //
-// Central coordinator for 1-shot chat execution (Tier 1).
-// Bypasses TaskLifecycle — calls adapter.execute() directly.
+// Central coordinator for chat execution.
 import { getPulseedDirPath } from "../../base/utils/paths.js";
 import { ChatHistory } from "./chat-history.js";
 import { ChatSessionCatalog, ChatSessionSelectorError, } from "./chat-session-store.js";
+import { chooseSingleRecoveryResumeCandidate, classifyRecoveryResumeIntent, formatNoRecoveryResumeCandidates, formatRecoveryResumeChoices, toRecoveryResumeCandidates, } from "./recovery-resume.js";
 import { buildChatContext, resolveGitRoot } from "../../platform/observation/context-provider.js";
 import { buildChatAgentLoopSystemPrompt, buildStaticSystemPrompt, createChatGroundingGateway } from "./grounding.js";
 import { classifyRuntimeControlIntent } from "../../runtime/control/index.js";
@@ -14,18 +14,36 @@ import { classifyInterruptRedirect, collectGitDiffArtifact, previewActivityText
 import { COMMAND_HELP, ChatRunnerCommandHandler, } from "./chat-runner-commands.js";
 import { ChatRunnerEventBridge } from "./chat-runner-event-bridge.js";
 import { intakeSetupSecrets } from "./setup-secret-intake.js";
-import { isSetupWriteConfirmCommand, SETUP_WRITE_CONFIRM_COMMAND, } from "./setup-dialogue.js";
+import { isSetupWriteConfirmCommand, } from "./setup-dialogue.js";
 import { detectTurnLanguageHint, sameLanguageResponseInstruction, UNKNOWN_TURN_LANGUAGE_HINT, } from "./turn-language.js";
 import { confirmTelegramGatewayConfigWrite } from "./setup-config-write.js";
 import { buildRuntimeControlContextFromIngress, buildStandaloneIngressMessageFromContext, formatRoute, getRouteCapabilities, loadedSessionToChatSession, resolveChatResumeSelector, } from "./chat-runner-runtime.js";
-import { executeAdapterRoute, executeAssistRoute, executeClarifyRoute, executeConfigureRoute, executeRunSpecDraftRoute, executeAgentLoopRoute, formatBlockedRuntimeControlRoute, executeRuntimeControlRoute, executeToolLoopRoute, resolveSessionExecutionPolicy, } from "./chat-runner-routes.js";
-import { classifyFreeformRouteIntent } from "./freeform-route-classifier.js";
-import { deriveRunSpecFromText } from "../../runtime/run-spec/index.js";
+import { executeConfigureRoute, executeAgentLoopRoute, executeGatewayModelLoopRoute, formatBlockedRuntimeControlRoute, executeRuntimeControlRoute, resolveSessionExecutionPolicy, } from "./chat-runner-routes.js";
 import { createTextUserInput, normalizeUserInput, replaceUserInputText } from "./user-input.js";
+import { createSeedyActiveTurnStatus, formatSeedyActiveTurnStatus, } from "./seedy-turn-presence.js";
 import { createTurnStartOperation, createTurnSteerOperation } from "./turn-protocol.js";
-import { buildChatTurnContext, renderSystemPromptWithTurnContext, toTurnContextSnapshot, } from "./turn-context.js";
+import { buildChatTurnContext, toTurnContextSnapshot, } from "./turn-context.js";
 import { createRunSpecStore, formatRunSpecSetupProposal, arbitrateRunSpecPendingDialogue, handleRunSpecConfirmationInput, RunSpecHandoffService, validateRunSpecStartSafety, } from "../../runtime/run-spec/index.js";
+import { parseResumeChoiceNumber } from "./resume-choice.js";
+import { formatPendingSetupConfirmationSubject, formatSetupConfirmationCancelled, formatTelegramSetupRefreshResult, } from "./chat-runner-setup-format.js";
+import { feedbackIngestionSourceForReplyTarget, feedbackSurfaceRefForReplyTarget, ingestFeedbackFromChatEvent, } from "./feedback-ingestion.js";
+import { createFeedbackIngestion } from "../../runtime/attention/index.js";
+import { resolveConfiguredDaemonRuntimeRoot } from "../../runtime/daemon/runtime-root.js";
+import { FeedbackIngestionStore } from "../../runtime/store/feedback-ingestion-store.js";
+import { CompanionCognitionService, createCognitionReplayRecord, createRelationshipProfileCognitionMemoryPort, } from "../../runtime/cognition/index.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
+function buildGatewayModelLoopSystemPrompt(basePrompt, languageHint) {
+    return [
+        basePrompt,
+        "You are Seedy on a gateway chat surface. Match Codex's chat shape: answer ordinary casual messages directly, and choose tools only when current state, setup, run-spec, implementation handoff, or inspection work is actually needed.",
+        "Do not invent current workspace, runtime, command, process, repository, file, or local-machine facts. If you need those facts, call an available tool first.",
+        "Default gateway tool contract: when the user explicitly asks to inspect current repository files, workspace state, PulSeed runtime/gateway/daemon/session state, setup state, or implementation status, use the relevant available tool before answering.",
+        "Do not answer tool-available inspection requests by telling the user to run local commands or manual checks themselves. If the relevant tool is unavailable, denied, or insufficient, say that plainly and keep the answer bounded to what was actually checked.",
+        "When using tools, write brief model-authored commentary only when it helps the user understand the real next step. Do not describe route selection, lifecycle phases, or internal PulSeed planning labels.",
+        "Keep PulSeed runtime-control actions behind the provided authorization and approval tools. Do not suggest shell commands as a workaround for unauthorized runtime control.",
+        sameLanguageResponseInstruction(languageHint),
+    ].filter((section) => section.trim().length > 0).join("\n\n");
+}
 function normalizePinnedReplyTarget(replyTarget) {
     if (!replyTarget)
         return null;
@@ -43,41 +61,6 @@ function normalizePinnedReplyTarget(replyTarget) {
     };
 }
 const standaloneIngressRouter = createIngressRouter();
-function formatPendingSetupConfirmationSubject(publicState) {
-    const lines = [
-        `Setup dialogue: ${publicState.selectedChannel}`,
-        `State: ${publicState.state}`,
-        `Action: ${publicState.action?.kind ?? "unknown"}`,
-        `Command fallback: ${publicState.action?.command ?? SETUP_WRITE_CONFIRM_COMMAND}`,
-        publicState.replacesExistingSecret
-            ? "Confirming will replace an existing configured Telegram bot token."
-            : "Confirming will write a Telegram gateway config from a redacted chat-supplied token.",
-        "Approval is still required before writing config.",
-    ];
-    return lines.join("\n");
-}
-function formatSetupConfirmationCancelled(languageHint) {
-    if (languageHint.language === "ja") {
-        return "Telegram setup の config write はキャンセルしました。token は書き込んでいません。";
-    }
-    return "Telegram setup config write was cancelled. No token was written.";
-}
-function formatTelegramSetupRefreshResult(result, languageHint) {
-    if (result.success) {
-        const suffix = result.operationId ? ` (${result.operationId})` : "";
-        return languageHint.language === "ja"
-            ? `PulSeed は更新済み Telegram gateway config を反映するため、internal gateway refresh を要求しました${suffix}: ${result.message}`
-            : `PulSeed requested an internal gateway refresh for the updated Telegram config${suffix}: ${result.message}`;
-    }
-    if (result.unavailable) {
-        return languageHint.language === "ja"
-            ? `PulSeed は internal gateway refresh を試みましたが、この chat surface では runtime control service が利用できません: ${result.message}`
-            : `PulSeed attempted an internal gateway refresh, but runtime control is unavailable in this chat surface: ${result.message}`;
-    }
-    return languageHint.language === "ja"
-        ? `PulSeed は internal gateway refresh を試みましたが失敗しました: ${result.message}`
-        : `PulSeed attempted an internal gateway refresh, but it failed: ${result.message}`;
-}
 export class ChatRunner {
     deps;
     groundingGateway;
@@ -93,16 +76,26 @@ export class ChatRunner {
     onNotification = undefined;
     onEvent = undefined;
     nativeAgentLoopStatePath = null;
+    nativeAgentLoopSessionId = null;
     runtimeControlContext = null;
     sessionExecutionPolicy = null;
     lastSelectedRoute = null;
     setupSecretIntake = null;
     turnLanguageHint = UNKNOWN_TURN_LANGUAGE_HINT;
     pendingSetupDialogue = null;
+    pendingResumeChoices = null;
     eventJournalHistory = null;
     eventJournalDirty = false;
+    feedbackIngestionStore;
+    companionCognitionService;
     constructor(deps) {
         this.deps = deps;
+        this.feedbackIngestionStore = deps.feedbackIngestionStore ?? createDefaultChatFeedbackIngestionStore(deps.stateManager);
+        this.companionCognitionService = deps.companionCognitionService ?? new CompanionCognitionService({
+            memoryPort: createRelationshipProfileCognitionMemoryPort({
+                baseDir: this.providerConfigBaseDir(),
+            }),
+        });
         this.groundingGateway = createChatGroundingGateway({
             stateManager: deps.stateManager,
             pluginLoader: deps.pluginLoader,
@@ -118,6 +111,8 @@ export class ChatRunner {
             setSessionActive: (active) => { this.sessionActive = active; },
             getNativeAgentLoopStatePath: () => this.nativeAgentLoopStatePath,
             setNativeAgentLoopStatePath: (path) => { this.nativeAgentLoopStatePath = path; },
+            getNativeAgentLoopSessionId: () => this.nativeAgentLoopSessionId,
+            setNativeAgentLoopSessionId: (sessionId) => { this.nativeAgentLoopSessionId = sessionId; },
             getRuntimeControlContext: () => this.runtimeControlContext,
             getPendingTend: () => this.pendingTend,
             setPendingTend: (value) => { this.pendingTend = value; },
@@ -136,8 +131,10 @@ export class ChatRunner {
         this.history = new ChatHistory(this.deps.stateManager, sessionId, gitRoot);
         this.sessionCwd = gitRoot;
         this.sessionActive = true;
-        this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
-        this.history.resetAgentLoopState(this.nativeAgentLoopStatePath);
+        this.nativeAgentLoopStatePath = null;
+        this.nativeAgentLoopSessionId = sessionId;
+        this.history.resetAgentLoopState(null);
+        this.history.setAgentLoopSessionIdentity({ sessionId, traceId: null });
         this.sessionExecutionPolicy = null;
     }
     startSessionFromLoadedSession(session) {
@@ -145,8 +142,13 @@ export class ChatRunner {
         this.history = ChatHistory.fromSession(this.deps.stateManager, chatSession);
         this.sessionCwd = resolveGitRoot(session.cwd);
         this.sessionActive = true;
-        this.nativeAgentLoopStatePath = session.agentLoopStatePath ?? `chat/agentloop/${session.id}.state.json`;
+        this.nativeAgentLoopStatePath = session.agentLoopStatePath ?? null;
+        this.nativeAgentLoopSessionId = session.agentLoopSessionId ?? session.id;
         this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        this.history.setAgentLoopSessionIdentity({
+            sessionId: this.nativeAgentLoopSessionId,
+            traceId: session.agentLoopTraceId ?? null,
+        });
         this.sessionExecutionPolicy = null;
     }
     getSessionId() {
@@ -155,9 +157,134 @@ export class ChatRunner {
     getCurrentSessionMessages() {
         return this.history?.getMessages() ?? [];
     }
+    async resolvePendingResumeSelection(input) {
+        const candidates = this.pendingResumeChoices;
+        if (!candidates || candidates.length === 0)
+            return null;
+        const choice = parseResumeChoiceNumber(input);
+        if (choice === null) {
+            this.pendingResumeChoices = null;
+            return null;
+        }
+        const candidate = candidates.find((item) => item.index === choice);
+        if (!candidate) {
+            return {
+                result: {
+                    success: false,
+                    output: formatRecoveryResumeChoices(candidates),
+                    elapsed_ms: 0,
+                },
+            };
+        }
+        this.pendingResumeChoices = null;
+        const catalog = new ChatSessionCatalog(this.deps.stateManager);
+        const session = await catalog.loadSession(candidate.sessionId);
+        if (!session) {
+            return {
+                result: {
+                    success: false,
+                    output: formatNoRecoveryResumeCandidates(),
+                    elapsed_ms: 0,
+                },
+            };
+        }
+        return { session };
+    }
+    async resolveResumeSelectorChoice(selector) {
+        const choice = parseResumeChoiceNumber(selector);
+        if (choice === null) {
+            this.pendingResumeChoices = null;
+            return null;
+        }
+        if (!this.pendingResumeChoices)
+            return null;
+        return this.resolvePendingResumeSelection(String(choice));
+    }
+    clearPendingResumeChoicesUnlessSelecting(input, resumeCommand) {
+        if (!this.pendingResumeChoices)
+            return;
+        const selectionInput = resumeCommand?.selector ?? input;
+        if (parseResumeChoiceNumber(selectionInput) === null) {
+            this.pendingResumeChoices = null;
+        }
+    }
+    async resolveNaturalRecoveryResume(input) {
+        if (!this.deps.chatAgentLoopRunner)
+            return null;
+        if (this.sessionActive)
+            return null;
+        const catalog = this.createChatSessionCatalog();
+        if (!catalog)
+            return null;
+        const sessions = await catalog.listSessions();
+        const candidates = toRecoveryResumeCandidates(sessions);
+        const decision = await classifyRecoveryResumeIntent(input, this.deps.llmClient);
+        if (!decision || decision.kind === "none")
+            return null;
+        if (candidates.length === 0) {
+            this.pendingResumeChoices = null;
+            return {
+                result: {
+                    success: false,
+                    output: formatNoRecoveryResumeCandidates(),
+                    elapsed_ms: 0,
+                },
+            };
+        }
+        if (decision.kind === "show_sessions" || decision.kind === "inspect_running") {
+            this.pendingResumeChoices = candidates;
+            return {
+                result: {
+                    success: true,
+                    output: formatRecoveryResumeChoices(candidates),
+                    elapsed_ms: 0,
+                },
+            };
+        }
+        if (decision.kind === "start_new") {
+            this.pendingResumeChoices = null;
+            return null;
+        }
+        const candidate = chooseSingleRecoveryResumeCandidate(candidates);
+        if (!candidate) {
+            this.pendingResumeChoices = candidates;
+            return {
+                result: {
+                    success: true,
+                    output: formatRecoveryResumeChoices(candidates),
+                    elapsed_ms: 0,
+                },
+            };
+        }
+        this.pendingResumeChoices = null;
+        const session = await catalog.loadSession(candidate.sessionId);
+        if (!session) {
+            return {
+                result: {
+                    success: false,
+                    output: formatNoRecoveryResumeCandidates(),
+                    elapsed_ms: 0,
+                },
+            };
+        }
+        return { session };
+    }
+    createChatSessionCatalog() {
+        const stateManager = this.deps.stateManager;
+        return typeof stateManager.getBaseDir === "function" ? new ChatSessionCatalog(this.deps.stateManager) : null;
+    }
     hasActiveTurn() {
         return this.eventBridge.hasActiveTurn();
     }
+    getActiveSeedyPresence() {
+        return this.eventBridge.getActiveSeedyPresence();
+    }
+    getActiveSeedyTurnStatus(options = {}) {
+        return createSeedyActiveTurnStatus(this.getActiveSeedyPresence(), options);
+    }
+    formatActiveSeedyTurnStatus(options = {}) {
+        return formatSeedyActiveTurnStatus(this.getActiveSeedyTurnStatus(options));
+    }
     async interruptAndRedirect(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
         const steerUserInput = normalizeUserInput(options.userInput, input);
         const activeTurn = this.eventBridge.getActiveTurn();
@@ -250,13 +377,15 @@ export class ChatRunner {
     setRuntimeControlContext(context) {
         this.runtimeControlContext = context;
     }
-    async executeIngressMessage(ingress, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, selectedRoute) {
-        if (!selectedRoute) {
+    async executeIngressMessage(ingress, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, selectedRoute, options = {}) {
+        if (!selectedRoute && !options.routeSelector) {
             throw new Error("executeIngressMessage requires selectedRoute; use CrossPlatformChatSessionManager for ingress route selection.");
         }
         const runtimeControlContext = buildRuntimeControlContextFromIngress(ingress, this.runtimeControlContext, this.deps);
         return this.execute(ingress.text, cwd, timeoutMs, {
-            selectedRoute,
+            ...(selectedRoute ? { selectedRoute } : {}),
+            ...(options.routeSelector ? { routeSelector: options.routeSelector } : {}),
+            presenceIngressId: ingress.ingress_id,
             runtimeControlContext,
             goalId: ingress.goal_id,
             userInput: ingress.userInput,
@@ -270,7 +399,7 @@ export class ChatRunner {
         this.eventJournalHistory = null;
         this.eventJournalDirty = false;
         const resumeCommand = this.commandHandler.parseResumeCommand(input);
-        const resumeOnly = resumeCommand !== null;
+        let resumeOnly = resumeCommand !== null;
         const setupSecretIntake = intakeSetupSecrets(input);
         this.setupSecretIntake = setupSecretIntake;
         const safeInput = setupSecretIntake.redactedText;
@@ -282,6 +411,15 @@ export class ChatRunner {
         const persistedSecretIntake = setupSecretIntake.suppliedSecrets.map(({ value: _value, ...metadata }) => metadata);
         const runtimeControlContext = options.runtimeControlContext ?? this.runtimeControlContext;
         const executionGoalId = options.goalId ?? this.deps.goalId;
+        await this.eventBridge.emitSeedyPresenceAndFlush("received", eventContext, {
+            ...(options.presenceIngressId ? { ingressId: options.presenceIngressId } : {}),
+            expectedNext: "progress",
+        });
+        await this.eventBridge.emitSeedyPresenceAndFlush("orienting", eventContext, {
+            ...(options.presenceIngressId ? { ingressId: options.presenceIngressId } : {}),
+            expectedNext: "progress",
+        });
+        this.clearPendingResumeChoicesUnlessSelecting(safeInput, resumeCommand);
         const pendingTelegramSetupResult = await this.handlePendingSetupConfirmation(safeInput, runtimeControlContext);
         if (pendingTelegramSetupResult !== null) {
             return this.finalizeNonPersistentResult(pendingTelegramSetupResult, eventContext);
@@ -298,37 +436,80 @@ export class ChatRunner {
             const confirmationResult = await this.commandHandler.handleTendConfirmation(safeInput.trim(), Date.now());
             return this.finalizeNonPersistentResult(confirmationResult, eventContext);
         }
-        if (resumeOnly && resumeCommand.selector) {
+        const pendingResumeSelection = !resumeOnly
+            ? await this.resolvePendingResumeSelection(safeInput)
+            : null;
+        if (pendingResumeSelection?.result) {
+            return this.finalizeNonPersistentResult(pendingResumeSelection.result, eventContext);
+        }
+        if (pendingResumeSelection?.session) {
+            this.startSessionFromLoadedSession(pendingResumeSelection.session);
+            resumeOnly = true;
+        }
+        if (resumeCommand?.selector) {
             try {
-                const selectorResolution = await resolveChatResumeSelector(resumeCommand.selector, this.deps);
-                if (selectorResolution.nonResumableMessage) {
-                    return this.finalizeNonPersistentResult({
-                        success: false,
-                        output: selectorResolution.nonResumableMessage,
-                        elapsed_ms: 0,
-                    }, eventContext);
+                const selectedChoice = await this.resolveResumeSelectorChoice(resumeCommand.selector);
+                if (selectedChoice?.result) {
+                    return this.finalizeNonPersistentResult(selectedChoice.result, eventContext);
                 }
-                const catalog = new ChatSessionCatalog(this.deps.stateManager);
-                const session = await catalog.loadSessionBySelector(selectorResolution.chatSelector);
-                if (!session) {
-                    return this.finalizeNonPersistentResult({
-                        success: false,
-                        output: `No chat session matched selector "${selectorResolution.chatSelector}".`,
-                        elapsed_ms: 0,
-                    }, eventContext);
+                if (selectedChoice?.session) {
+                    this.startSessionFromLoadedSession(selectedChoice.session);
+                }
+                else {
+                    const selectorResolution = await resolveChatResumeSelector(resumeCommand.selector, this.deps);
+                    if (selectorResolution.nonResumableMessage) {
+                        return this.finalizeNonPersistentResult({
+                            success: false,
+                            output: selectorResolution.nonResumableMessage,
+                            elapsed_ms: 0,
+                        }, eventContext);
+                    }
+                    const catalog = new ChatSessionCatalog(this.deps.stateManager);
+                    const session = await catalog.loadSessionBySelector(selectorResolution.chatSelector);
+                    if (!session) {
+                        return this.finalizeNonPersistentResult({
+                            success: false,
+                            output: `No chat session matched selector "${selectorResolution.chatSelector}".`,
+                            elapsed_ms: 0,
+                        }, eventContext);
+                    }
+                    this.startSessionFromLoadedSession(session);
                 }
-                this.startSessionFromLoadedSession(session);
             }
             catch (err) {
                 const output = err instanceof ChatSessionSelectorError ? err.message : `Failed to load chat session: ${err instanceof Error ? err.message : String(err)}`;
                 return this.finalizeNonPersistentResult({ success: false, output, elapsed_ms: 0 }, eventContext);
             }
         }
+        let resolvedRoute = options.selectedRoute;
+        if (!resumeOnly && !resolvedRoute && options.routeSelector) {
+            resolvedRoute = await options.routeSelector({
+                safeInput,
+                setupSecretIntake,
+                runtimeControlContext,
+                eventContext,
+                cwd: resolvedCwd,
+                sessionId: this.getSessionId(),
+            });
+        }
+        const shouldResolveNaturalRecovery = !resolvedRoute || resolvedRoute.kind === "agent_loop";
+        if (!resumeOnly && pendingResumeSelection === null && shouldResolveNaturalRecovery) {
+            const naturalRecovery = await this.resolveNaturalRecoveryResume(safeInput);
+            if (naturalRecovery?.result) {
+                return this.finalizeNonPersistentResult(naturalRecovery.result, eventContext);
+            }
+            if (naturalRecovery?.session) {
+                this.startSessionFromLoadedSession(naturalRecovery.session);
+                resumeOnly = true;
+            }
+        }
         if (!this.sessionActive) {
             const sessionId = crypto.randomUUID();
             this.history = new ChatHistory(this.deps.stateManager, sessionId, resolvedCwd);
-            this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
-            this.history.resetAgentLoopState(this.nativeAgentLoopStatePath);
+            this.nativeAgentLoopStatePath = null;
+            this.nativeAgentLoopSessionId = sessionId;
+            this.history.resetAgentLoopState(null);
+            this.history.setAgentLoopSessionIdentity({ sessionId, traceId: null });
         }
         const executionCwd = this.sessionCwd ?? resolvedCwd;
         const gitRoot = this.sessionCwd ?? resolvedCwd;
@@ -337,7 +518,16 @@ export class ChatRunner {
         this.eventJournalHistory = history;
         this.eventBridge.setEventRecorder((event) => {
             this.eventJournalDirty = true;
-            return history.recordChatEvent(event, { persist: false });
+            const feedbackReplyTarget = runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget ?? null;
+            const feedbackSource = feedbackIngestionSourceForReplyTarget(feedbackReplyTarget);
+            return Promise.all([
+                history.recordChatEvent(event, { persist: false }),
+                ingestFeedbackFromChatEvent(event, {
+                    store: this.feedbackIngestionStore,
+                    source: feedbackSource,
+                    surfaceRef: feedbackSurfaceRefForReplyTarget(feedbackSource, feedbackReplyTarget),
+                }),
+            ]).then(() => undefined);
         });
         const pinnedReplyTarget = normalizePinnedReplyTarget(runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget ?? null);
         if (pinnedReplyTarget) {
@@ -387,10 +577,31 @@ export class ChatRunner {
         const assistantBuffer = { text: "" };
         const selectedRoute = resumeOnly
             ? null
-            : (options.selectedRoute ?? await this.resolveRouteFromInput(safeInput, runtimeControlContext, resolvedCwd));
+            : (resolvedRoute ?? await this.resolveRouteFromInput(safeInput, runtimeControlContext, resolvedCwd, options.runtimeControlContext?.explicit === true));
         this.lastSelectedRoute = selectedRoute;
-        if (selectedRoute?.kind !== "configure") {
-            this.eventBridge.emitIntent(safeInput, selectedRoute, eventContext);
+        const usesGatewayModelLoop = selectedRoute?.kind === "gateway_model_loop";
+        if (usesGatewayModelLoop) {
+            this.eventBridge.emitSeedyPresence("thinking", eventContext, {
+                ...(options.presenceIngressId ? { ingressId: options.presenceIngressId } : {}),
+                subject: "Reading message",
+                reason: "Seedy is preparing the reply.",
+                expectedNext: "final",
+            });
+        }
+        else if (selectedRoute) {
+            this.eventBridge.emitSeedyPresence("thinking", eventContext, {
+                ...(options.presenceIngressId ? { ingressId: options.presenceIngressId } : {}),
+                subject: "Working on the response",
+                reason: "Seedy is preparing the next step.",
+                expectedNext: "progress",
+            });
+        }
+        if (selectedRoute && !usesGatewayModelLoop) {
+            this.eventBridge.emitSeedyPresence("acting", eventContext, {
+                ...(options.presenceIngressId ? { ingressId: options.presenceIngressId } : {}),
+                reason: "PulSeed is executing the selected path.",
+                expectedNext: "progress",
+            });
         }
         if (selectedRoute?.kind === "runtime_control") {
             this.eventBridge.emitCheckpoint("Runtime control selected", `${selectedRoute.intent.kind} request recognized.`, eventContext, "route");
@@ -398,7 +609,6 @@ export class ChatRunner {
             if (runtimeControlResult.success) {
                 await history.appendAssistantMessage(runtimeControlResult.output, { eventContext });
                 this.eventBridge.emitCheckpoint("Runtime control completed", "The runtime-control operation produced a result.", eventContext, "complete");
-                this.eventBridge.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
                 this.eventBridge.emitEvent({
                     type: "assistant_final",
                     text: runtimeControlResult.output,
@@ -437,25 +647,20 @@ export class ChatRunner {
                 elapsed_ms,
             });
         }
-        if (selectedRoute?.kind === "run_spec_draft") {
-            const result = await executeRunSpecDraftRoute(this.routeHost(), selectedRoute, eventContext, assistantBuffer, history, start);
-            return this.flushAndReturn(result);
-        }
         if (selectedRoute?.kind === "configure") {
             const result = await executeConfigureRoute(this.routeHost(), selectedRoute, eventContext, assistantBuffer, history, start);
             return this.flushAndReturn(result);
         }
-        if (selectedRoute?.kind === "clarify") {
-            const result = await executeClarifyRoute(this.routeHost(), selectedRoute, eventContext, assistantBuffer, history, start);
-            return this.flushAndReturn(result);
-        }
         const usesNativeAgentLoop = resumeOnly || selectedRoute?.kind === "agent_loop";
         const executionPolicy = await this.getSessionExecutionPolicy();
         const groundingWorkspaceContext = !resumeOnly && usesNativeAgentLoop
             ? await buildChatContext(safeInput, executionCwd)
             : undefined;
         let systemPrompt = this.cachedStaticSystemPrompt ?? "";
-        if (!resumeOnly) {
+        if (!resumeOnly && usesGatewayModelLoop) {
+            systemPrompt = buildGatewayModelLoopSystemPrompt(this.cachedStaticSystemPrompt ?? "", this.turnLanguageHint);
+        }
+        else if (!resumeOnly) {
             try {
                 this.eventBridge.emitActivity("lifecycle", "Preparing context...", eventContext, "lifecycle:context");
                 if (usesNativeAgentLoop) {
@@ -473,6 +678,7 @@ export class ChatRunner {
                     const groundingBundle = await this.groundingGateway.build({
                         surface: "chat",
                         purpose: "general_turn",
+                        userVisibleSink: true,
                         workspaceRoot: executionCwd,
                         goalId: executionGoalId,
                         userMessage: safeInput,
@@ -486,7 +692,7 @@ export class ChatRunner {
                 systemPrompt = this.cachedStaticSystemPrompt ?? "";
             }
             this.eventBridge.emitCheckpoint("Context gathered", usesNativeAgentLoop
-                ? "Workspace and agent-loop grounding are ready."
+                ? "Workspace and tool context are ready."
                 : "Workspace grounding is ready.", eventContext, "context");
         }
         const agentLoopSystemPrompt = [
@@ -497,7 +703,7 @@ export class ChatRunner {
             .filter((section) => section && section.trim().length > 0)
             .join("\n\n")
             .trim();
-        const context = resumeOnly || usesNativeAgentLoop ? "" : await buildChatContext(safeInput, gitRoot);
+        const context = resumeOnly || usesNativeAgentLoop || usesGatewayModelLoop ? "" : await buildChatContext(safeInput, gitRoot);
         const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${safeInput}` : safeInput);
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
         const turnContext = buildChatTurnContext({
@@ -508,6 +714,7 @@ export class ChatRunner {
             gitRoot,
             executionCwd,
             nativeAgentLoopStatePath: this.nativeAgentLoopStatePath,
+            nativeAgentLoopSessionId: this.nativeAgentLoopSessionId,
             selectedRoute,
             input: safeInput,
             userInput: safeUserInput,
@@ -529,25 +736,18 @@ export class ChatRunner {
             activatedTools: this.activatedTools,
         });
         await history.recordTurnContext(toTurnContextSnapshot(turnContext));
+        if (!resumeOnly && (selectedRoute?.kind === "agent_loop" || selectedRoute?.kind === "gateway_model_loop")) {
+            await this.recordShadowCognition(turnContext, history);
+        }
         if (resumeOnly && !this.deps.chatAgentLoopRunner) {
             const elapsed_ms = Date.now() - start;
-            const output = await this.eventBridge.emitLifecycleErrorEventWithFallback("Resume requires the native chat agentloop runtime.", assistantBuffer.text, eventContext, {
+            const output = await this.eventBridge.emitLifecycleErrorEventWithFallback("Continuing a saved chat is not available in this mode.", assistantBuffer.text, eventContext, {
                 code: "resume_state_missing",
                 stoppedReason: "resume_state_missing",
             }, this.deps.llmClient);
             this.eventBridge.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
             return this.flushAndReturn({ success: false, output, elapsed_ms });
         }
-        if (selectedRoute?.kind === "assist") {
-            const result = await executeAssistRoute(this.routeHost(), {
-                turnContext,
-                eventContext,
-                assistantBuffer,
-                history,
-                start,
-            });
-            return this.flushAndReturn(result);
-        }
         if (resumeOnly || selectedRoute?.kind === "agent_loop") {
             return this.flushAndReturn(executeAgentLoopRoute(this.routeHost(), {
                 turnContext,
@@ -560,8 +760,8 @@ export class ChatRunner {
                 start,
             }));
         }
-        if (selectedRoute?.kind === "tool_loop") {
-            return this.flushAndReturn(executeToolLoopRoute(this.routeHost(), {
+        if (selectedRoute?.kind === "gateway_model_loop") {
+            return this.flushAndReturn(executeGatewayModelLoopRoute(this.routeHost(), {
                 turnContext,
                 eventContext,
                 assistantBuffer,
@@ -570,25 +770,122 @@ export class ChatRunner {
                 history,
                 gitRoot,
                 runtimeControlContext,
+                activeAbortSignal: activeTurn.abortController.signal,
+                timeoutMs,
                 start,
             }));
         }
-        if (!resumeOnly && selectedRoute && selectedRoute.kind !== "adapter") {
-            const elapsed_ms = Date.now() - start;
-            const output = await this.eventBridge.emitLifecycleErrorEventWithFallback(`Unsupported chat route: ${selectedRoute.kind}`, assistantBuffer.text, eventContext, {}, this.deps.llmClient);
-            this.eventBridge.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
-            return this.flushAndReturn({ success: false, output, elapsed_ms });
+        const elapsed_ms = Date.now() - start;
+        const routeKind = selectedRoute?.kind ?? "none";
+        const output = await this.eventBridge.emitLifecycleErrorEventWithFallback(`Unsupported chat route: ${routeKind}`, assistantBuffer.text, eventContext, {}, this.deps.llmClient);
+        this.eventBridge.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+        return this.flushAndReturn({ success: false, output, elapsed_ms });
+    }
+    async recordShadowCognition(turnContext, history) {
+        const input = this.buildChatCognitionInput(turnContext);
+        const createdAt = new Date().toISOString();
+        try {
+            const output = await this.companionCognitionService.evaluateTurn(input);
+            await history.recordCognitionAudit(createCognitionReplayRecord({
+                recordId: `${input.cognition_id}:chat-history-record`,
+                createdAt,
+                input,
+                output,
+            }));
         }
-        return this.flushAndReturn(executeAdapterRoute(this.routeHost(), {
-            turnContext,
-            timeoutMs,
-            systemPrompt: renderSystemPromptWithTurnContext(systemPrompt || undefined, turnContext.modelVisible),
-            eventContext,
-            assistantBuffer,
-            gitRoot,
-            start,
-            history,
-        }));
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await history.recordCognitionAudit(createCognitionReplayRecord({
+                recordId: `${input.cognition_id}:chat-history-record`,
+                createdAt,
+                input,
+                failure: {
+                    message,
+                    retryable: true,
+                },
+            }));
+        }
+    }
+    buildChatCognitionInput(turnContext) {
+        const turn = turnContext.modelVisible.turn;
+        const session = turnContext.modelVisible.session;
+        const routeKind = session.route?.kind === "agent_loop" ? "agent_loop" : "gateway_model_loop";
+        const inputRef = {
+            ref: `${session.sessionId ?? "session:none"}:${turn.turnId}:user_input`,
+            source_store: "chat_history",
+            source_event_type: "user_input",
+            schema_version: 1,
+            source_epoch: turn.turnId,
+            redaction_policy: "metadata_only",
+        };
+        const cognitionId = `cognition:chat:${turn.turnId}`;
+        return {
+            cognition_id: cognitionId,
+            caller_path: "chat_user_turn",
+            event_refs: [inputRef],
+            working_context: {
+                input_ref: inputRef,
+                current_text_ref: `${session.sessionId ?? "session:none"}:${turn.turnId}:text`,
+                route_ref: {
+                    kind: "chat_route",
+                    ref: routeKind,
+                },
+                ...(session.sessionId
+                    ? {
+                        session_ref: {
+                            kind: "chat_session",
+                            ref: session.sessionId,
+                        },
+                    }
+                    : {}),
+                turn_started_at: turn.startedAt,
+                hidden_prompt_content_materialized: false,
+            },
+            session_context: {
+                session_ref: {
+                    kind: "chat_session",
+                    ref: session.sessionId ?? "session:none",
+                },
+                turn_ref: {
+                    kind: "chat_turn",
+                    ref: turn.turnId,
+                },
+                run_ref: {
+                    kind: "chat_run",
+                    ref: turn.runId,
+                },
+                route_kind: routeKind,
+                runtime_control_allowed: turnContext.modelVisible.runtime.runtimeControlAllowed,
+                approval_mode: turnContext.modelVisible.runtime.approvalMode,
+                quieting_active: false,
+                stale_reply_target_refs: [],
+            },
+            goal_context: turnContext.hostOnly.execution.goalId
+                ? {
+                    active_goals: [{
+                            goal_id: turnContext.hostOnly.execution.goalId,
+                            goal_ref: {
+                                kind: "goal",
+                                ref: turnContext.hostOnly.execution.goalId,
+                            },
+                            lifecycle: "active",
+                            priority: "unknown",
+                        }],
+                    active_intention_refs: [],
+                    stale_target_refs: [],
+                }
+                : undefined,
+            memory_context_request: {
+                request_id: `${cognitionId}:memory-request`,
+                requested_uses: ["runtime_grounding", "user_facing_reference"],
+                caller_path: "chat_user_turn",
+                query_ref: inputRef,
+                surface_projection_required: true,
+                side_effect_authorization_allowed: false,
+                include_sensitive_content: false,
+            },
+            surface_target: "internal_audit",
+        };
     }
     getSessionCwd() {
         return this.sessionCwd;
@@ -596,82 +893,42 @@ export class ChatRunner {
     getNativeAgentLoopStatePath() {
         return this.nativeAgentLoopStatePath;
     }
+    getNativeAgentLoopSessionId() {
+        return this.nativeAgentLoopSessionId;
+    }
     setSessionExecutionPolicy(policy) {
         this.sessionExecutionPolicy = policy;
     }
     async getSessionExecutionPolicy() {
-        const policy = await resolveSessionExecutionPolicy(this.sessionExecutionPolicy, this.sessionCwd);
+        const policy = await resolveSessionExecutionPolicy(this.sessionExecutionPolicy, this.sessionCwd, this.deps.defaultExecutionSecurity);
         this.sessionExecutionPolicy = policy;
         return policy;
     }
     async resolveRouteFromIngress(ingress) {
         const capabilities = getRouteCapabilities(this.deps);
         const hasSetupSecret = (this.setupSecretIntake?.suppliedSecrets.length ?? 0) > 0;
-        const shouldPreferFreeformBeforeDeniedRuntimeControl = !hasSetupSecret
-            && !capabilities.hasAgentLoop
-            && ingress.metadata["runtime_control_denied"] === true
-            && ingress.metadata["runtime_control_approved"] !== true
-            && ingress.metadata["runtime_control_explicit"] !== true;
-        const shouldClassifyRuntimeControlForSafety = !hasSetupSecret
-            && capabilities.hasAgentLoop
-            && (ingress.metadata["runtime_control_approved"] === true
-                || ingress.metadata["runtime_control_denied"] === true
-                || ingress.metadata["runtime_control_explicit"] === true);
-        const shouldClassifyRuntimeControl = shouldClassifyRuntimeControlForSafety
-            || (!hasSetupSecret && !capabilities.hasAgentLoop && ((capabilities.hasRuntimeControlService && ingress.runtimeControl.approvalMode !== "disallowed")
-                || ingress.metadata["runtime_control_approved"] === true
-                || ingress.metadata["runtime_control_denied"] === true
-                || ingress.metadata["runtime_control_explicit"] === true));
-        let freeformRouteIntent = shouldPreferFreeformBeforeDeniedRuntimeControl
-            ? await classifyFreeformRouteIntent(ingress.text, this.deps.llmClient)
-            : null;
-        const runtimeControlClassification = freeformRouteIntent == null && shouldClassifyRuntimeControl
+        const metadataRuntimeControlExplicit = ingress.metadata["runtime_control_explicit"] === true;
+        const shouldClassifyRuntimeControl = !hasSetupSecret
+            && metadataRuntimeControlExplicit;
+        const runtimeControlClassification = shouldClassifyRuntimeControl
             ? await classifyRuntimeControlIntent(ingress.text, this.deps.llmClient)
             : null;
         const runtimeControlIntent = runtimeControlClassification?.status === "intent"
             ? runtimeControlClassification.intent
             : null;
-        if (!hasSetupSecret && !capabilities.hasAgentLoop && freeformRouteIntent == null && runtimeControlIntent === null) {
-            freeformRouteIntent = await classifyFreeformRouteIntent(ingress.text, this.deps.llmClient);
-        }
-        const shouldDeriveRunSpecDraft = !capabilities.hasAgentLoop
-            && !hasSetupSecret
-            && runtimeControlIntent === null
-            && freeformRouteIntent != null
-            && (freeformRouteIntent.kind === "run_spec"
-                || freeformRouteIntent.kind === "configure"
-                || freeformRouteIntent.kind === "clarify")
-            && freeformRouteIntent.confidence >= 0.7;
-        const runSpecDraft = shouldDeriveRunSpecDraft
-            ? await deriveRunSpecFromText(ingress.text, {
-                cwd: ingress.cwd ?? this.sessionCwd ?? undefined,
-                conversationId: ingress.conversation_id ?? null,
-                channel: ingress.channel,
-                sessionId: this.history?.getSessionId() ?? ingress.conversation_id ?? null,
-                replyTarget: ingress.replyTarget,
-                originMetadata: {
-                    ingress_id: ingress.ingress_id ?? null,
-                    platform: ingress.platform ?? null,
-                    message_id: ingress.message_id ?? null,
-                    deliveryMode: ingress.deliveryMode ?? null,
-                    metadata: ingress.metadata,
-                },
-                llmClient: this.deps.llmClient,
-            })
-            : null;
         return standaloneIngressRouter.selectRoute(ingress, {
             ...capabilities,
             runtimeControlIntent,
-            runtimeControlUnclassified: shouldClassifyRuntimeControlForSafety
+            runtimeControlUnclassified: metadataRuntimeControlExplicit
                 && runtimeControlClassification?.status === "unclassified"
-                && ingress.metadata["runtime_control_explicit"] === true,
-            freeformRouteIntent,
+                && !hasSetupSecret,
             setupSecretIntake: this.setupSecretIntake,
-            runSpecDraft,
         });
     }
-    async resolveRouteFromInput(input, runtimeControlContext, cwd) {
-        const ingress = buildStandaloneIngressMessageFromContext(input, runtimeControlContext, this.deps);
+    async resolveRouteFromInput(input, runtimeControlContext, cwd, runtimeControlExplicit = false) {
+        const ingress = buildStandaloneIngressMessageFromContext(input, runtimeControlContext, this.deps, {
+            runtimeControlExplicit,
+        });
         return this.resolveRouteFromIngress(cwd ? { ...ingress, cwd } : ingress);
     }
     loadedSessionToChatSession(session) {
@@ -685,6 +942,7 @@ export class ChatRunner {
             getConversationSessionId: () => this.history?.getSessionId() ?? null,
             getSessionCwd: () => this.sessionCwd,
             getNativeAgentLoopStatePath: () => this.nativeAgentLoopStatePath,
+            getNativeAgentLoopSessionId: () => this.nativeAgentLoopSessionId,
             getProviderConfigBaseDir: () => this.providerConfigBaseDir(),
             getSetupSecretIntake: () => this.setupSecretIntake,
             getTurnLanguageHint: () => this.turnLanguageHint,
@@ -708,7 +966,7 @@ export class ChatRunner {
         return typeof stateManager.getBaseDir === "function" ? stateManager.getBaseDir() : getPulseedDirPath();
     }
     async reloadProviderRuntime() {
-        const [{ buildAdapterRegistry, buildLLMClient }, { loadProviderConfig }, { createNativeChatAgentLoopRunner, createNativeReviewAgentLoopRunner, shouldUseNativeTaskAgentLoop, },] = await Promise.all([
+        const [{ buildAdapterRegistry, buildGatewayLLMClient }, { loadProviderConfig }, { createNativeChatAgentLoopRunner, createNativeReviewAgentLoopRunner, shouldUseNativeTaskAgentLoop, },] = await Promise.all([
             import("../../base/llm/provider-factory.js"),
             import("../../base/llm/provider-config.js"),
             import("../../orchestrator/execution/agent-loop/index.js"),
@@ -717,10 +975,11 @@ export class ChatRunner {
             baseDir: this.providerConfigBaseDir(),
             saveMigration: false,
         });
-        const llmClient = await buildLLMClient(providerConfig);
+        const llmClient = await buildGatewayLLMClient(providerConfig);
         const adapterRegistry = await buildAdapterRegistry(llmClient, providerConfig);
         this.deps.llmClient = llmClient;
         this.deps.adapter = adapterRegistry.getAdapter(providerConfig.adapter);
+        this.deps.defaultExecutionSecurity = providerConfig.agent_loop?.security;
         this.deps.chatAgentLoopRunner = this.deps.registry && this.deps.toolExecutor && shouldUseNativeTaskAgentLoop(providerConfig, llmClient)
             ? createNativeChatAgentLoopRunner({
                 llmClient,
@@ -789,7 +1048,7 @@ export class ChatRunner {
             await this.history?.persist();
             return {
                 success: false,
-                output: `${result.message}\nNo background run was started.`,
+                output: `${result.message}\nNo background work was started.`,
                 elapsed_ms: Date.now() - start,
             };
         }
@@ -807,7 +1066,7 @@ export class ChatRunner {
                 output: [
                     proposal,
                     "",
-                    "RunSpec updated. Reply with approval to confirm, cancel to discard it, or provide another update.",
+                    "Long-running work updated. Reply with approval to confirm, cancel to discard it, or provide another update.",
                 ].join("\n"),
                 elapsed_ms: Date.now() - start,
             };
@@ -874,7 +1133,7 @@ export class ChatRunner {
                 await this.history?.persist();
                 return {
                     success: false,
-                    output: formatSetupConfirmationCancelled(this.turnLanguageHint),
+                    output: formatSetupConfirmationCancelled(),
                     elapsed_ms: 0,
                 };
             }
@@ -946,28 +1205,18 @@ export class ChatRunner {
         return {
             success: true,
             output: [
-                this.turnLanguageHint.language === "ja"
-                    ? "redacted chat-supplied token から Telegram gateway config を書き込みました。"
-                    : "Telegram gateway config was written from the redacted chat-supplied token.",
+                "Telegram gateway config was written from the redacted chat-supplied token.",
                 "",
-                formatTelegramSetupRefreshResult(writeResult.refresh, this.turnLanguageHint),
+                formatTelegramSetupRefreshResult(writeResult.refresh),
                 "",
-                this.turnLanguageHint.language === "ja" ? "Next steps:" : "Next steps:",
+                "Next steps:",
                 ...(writeResult.accessClosedByDefault
-                    ? [this.turnLanguageHint.language === "ja"
-                            ? "- allowed Telegram user IDs を設定するか、`pulseed telegram setup` で意図的に `allow_all` を有効にするまで access は closed のままです。"
-                            : "- Access remains closed until you configure allowed Telegram user IDs or intentionally enable `allow_all` with `pulseed telegram setup`."]
+                    ? ["- Access remains closed until you configure allowed Telegram user IDs or intentionally enable `allow_all` with `pulseed telegram setup`."]
                     : []),
-                this.turnLanguageHint.language === "ja"
-                    ? "- home chat が未設定なら Telegram から `/sethome` を送ってください。"
-                    : "- Send `/sethome` from Telegram if no home chat is configured yet.",
+                "- Send `/sethome` from Telegram if no home chat is configured yet.",
                 writeResult.refresh.success
-                    ? this.turnLanguageHint.language === "ja"
-                        ? "- Telegram bot にメッセージを送って動作確認してください。"
-                        : "- Send a message to the Telegram bot to verify delivery."
-                    : this.turnLanguageHint.language === "ja"
-                        ? "- 自動反映できませんでした。daemon lifecycle 操作は typed runtime-control が利用可能な chat surface から再実行してください。"
-                        : "- Automatic refresh was not applied. Retry the lifecycle refresh from a chat surface with typed runtime-control available.",
+                    ? "- Send a message to the Telegram bot to verify delivery."
+                    : "- Automatic gateway reload was not applied. Retry from a chat surface that can request gateway lifecycle actions.",
             ].join("\n"),
             elapsed_ms: 0,
         };
@@ -997,4 +1246,16 @@ export class ChatRunner {
 }
 void COMMAND_HELP;
 void formatRoute;
+function createDefaultChatFeedbackIngestionStore(stateManager) {
+    const getBaseDir = stateManager.getBaseDir;
+    if (typeof getBaseDir === "function") {
+        const baseDir = getBaseDir.call(stateManager);
+        return new FeedbackIngestionStore(resolveConfiguredDaemonRuntimeRoot(baseDir), { controlBaseDir: baseDir });
+    }
+    return {
+        async ingest(input) {
+            return createFeedbackIngestion(input);
+        },
+    };
+}
 //# sourceMappingURL=chat-runner.js.map