@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

package/dist/worker/console/chat/pi-runtime.js

@@ -33,6 +33,8 @@ import { parseProviderError, } from "./provider-error.js";
 import { projectCompactSnapshot, } from "./chat-event-store.js";
 import { extractUsageSample } from "./usage.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.js";
+import { authorizeChatSessionTool, DEFAULT_CONSOLE_CHAT_SESSION_MODE, PI_TODO_WRITE_DESCRIPTION, chatActiveToolBaseline, composeChatSystemPrompt, composeChatSystemPromptParts, computeChatActiveToolNames, shouldInjectGoalContinuation, shouldLoadWorkflowBusinessTools, } from "./session-mode.js";
+import { buildAgentCustomTool, ExploreOrchestrator, } from "./subagents/index.js";
 import { createOperatorChatResourceLoader, } from "./resource-loader.js";
 import { applySkillAutoInvocationPreferences, isAutoInvocationEnabled, loadResourcePreferences, skillResourceId, } from "./resource-preferences-store.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
@@ -42,6 +44,8 @@ import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.
 import { filterActiveInterviewTools } from "../interview/tools.js";
 import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.js";
 import { buildTodoContinuationContext, } from "./todos.js";
+import { buildPersistentTerminalTools } from "./terminal-tools.js";
+import { buildScmTools } from "./scm-tools.js";
 import { buildGoalContinuationContext, } from "./goals.js";
 import { injectWizardLocalHeaders, } from "./sdd-data-alignment.js";
 /**
@@ -74,15 +78,6 @@ export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "Continue until success, user stop, or no safe recovery remains; then stop and report failure/evidence. Never create a new task for a transient failure or replace repair-pi with direct edits.",
     "Narrate long-DAG progress briefly at start, meaningful phase changes/findings, verification failure/recovery, prolonged quiet and terminal state: say what finished and what is next. Never narrate unchanged operationWait polls or heartbeats, or claim beyond structured facts.",
 ].join("\n");
-/** Compose the inspectable system prompt actually injected into Operator Chat. */
-export function composeOperatorChatSystemPrompt(input) {
-    return [
-        OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
-        ...(input.systemPromptSuffix?.trim()
-            ? [input.systemPromptSuffix.trim()]
-            : []),
-    ].join("\n\n");
-}
 /**
  * Built-in SDK tool names registered for every Chat session (ADR 0011).
  * Full Pi builtins: read/write/edit/bash/grep/find/ls. safe-* custom tools
@@ -111,26 +106,8 @@ export const OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS = Object.freeze([
     "git-diff",
 ]);
 export function OPERATOR_CHAT_ACTIVE_TOOL_NAMES() {
-    return [
-        ...OPERATOR_CHAT_ALLOWED_TOOLS,
-        ...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS,
-        ...OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS,
-    ];
+    return chatActiveToolBaseline("workflow");
 }
-/**
- * Non-Pi write / coding channels that must never be activated in Operator
- * Chat even when a user/project extension registers them (ADR 0011 / 0012).
- * Mirrors the NON_PI_WRITE_CHANNELS guard in tools.ts for the Gate 2 pin.
- */
-const OPERATOR_CHAT_EXTENSION_DENIED_TOOL_IDS = new Set([
-    "apply_patch",
-    "apply-patch",
-    "full-tools",
-    "full_tools",
-    "coding-chat",
-    "coding_chat",
-    "shell",
-].map((t) => t.toLowerCase()));
 /**
  * Gate 2 active-tool set for a live session (ADR 0012): the operator-chat
  * baseline (operator actions + Pi builtins + safe explore) PLUS extension
@@ -141,24 +118,8 @@ const OPERATOR_CHAT_EXTENSION_DENIED_TOOL_IDS = new Set([
  * coding-chat). Unknown/denied names are never activated; Gate 3 still
  * re-authorizes every tool call per invocation.
  */
-export function computeOperatorChatActiveToolNames(session) {
-    const baseline = OPERATOR_CHAT_ACTIVE_TOOL_NAMES();
-    if (!session?.getAllTools)
-        return baseline;
-    const baselineLower = new Set(baseline.map((t) => t.toLowerCase()));
-    const extras = [];
-    for (const tool of session.getAllTools()) {
-        const name = tool?.name;
-        if (!name || typeof name !== "string")
-            continue;
-        const lower = name.toLowerCase();
-        if (baselineLower.has(lower))
-            continue;
-        if (OPERATOR_CHAT_EXTENSION_DENIED_TOOL_IDS.has(lower))
-            continue;
-        extras.push(name);
-    }
-    return extras.length > 0 ? [...baseline, ...extras] : baseline;
+export function computeOperatorChatActiveToolNames(session, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
+    return computeChatActiveToolNames(session, sessionMode);
 }
 const OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS = Object.freeze([
     "apply_patch",
@@ -214,8 +175,8 @@ async function bindSessionExtensions(session) {
         return;
     await session.bindExtensions(createConsoleExtensionBindings());
 }
-function pinOperatorChatTools(session) {
-    session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
+function pinOperatorChatTools(session, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
+    session.setActiveToolsByName(computeChatActiveToolNames(session, sessionMode));
 }
 /**
  * Pi has no hook result that merely appends instructions to its built-in
@@ -367,7 +328,7 @@ async function buildCustomOperatorTools(options) {
             promptSnippet: schema.description,
             parameters: parameters,
             async execute(toolCallId, params) {
-                const decision = authorizeOperatorChatTool(schema.toolId);
+                const decision = authorizeChatSessionTool(schema.toolId, options.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE);
                 if (!decision.ok) {
                     return {
                         content: [
@@ -384,7 +345,7 @@ async function buildCustomOperatorTools(options) {
                 }
                 // Defer require to avoid circular import at module load.
                 const { dispatchChatToolCall } = await import("./session-store.js");
-                const result = await dispatchChatToolCall(ctx, decision.toolId, params, toolCallId);
+                const result = await dispatchChatToolCall(ctx, decision.toolId, params, toolCallId, options.sessionMode);
                 const payload = result.ok
                     ? result.result
                     : { error: result.message, code: result.errorCode };
@@ -442,11 +403,14 @@ async function buildTodoWriteTool(options) {
         import("typebox"),
         import("@earendil-works/pi-coding-agent"),
     ]);
+    const description = options.sessionMode === "pi"
+        ? PI_TODO_WRITE_DESCRIPTION
+        : TODO_WRITE_DESCRIPTION;
     return defineTool({
         name: "todo_write",
         label: "Update todo list",
-        description: TODO_WRITE_DESCRIPTION,
-        promptSnippet: TODO_WRITE_DESCRIPTION,
+        description,
+        promptSnippet: description,
         parameters: Type.Object({
             todos: Type.Array(Type.Object({
                 content: Type.String({ description: "Short imperative task description." }),
@@ -1019,19 +983,43 @@ export class ConsolePiRuntime {
     sessionInit = new Map();
     /** Resolved model binding after materialization (create may return before this is known). */
     sessionModels = new Map();
+    /** Durable session mode; record is the source of truth, this is the live handle cache. */
+    sessionModes = new Map();
     /** SessionIds disposed while materialization was still in flight. */
     disposedSessions = new Set();
     compactionControllers = new Map();
     siftStates = new Map();
     /** Session-less tool definition caches (no AgentSession state). */
-    /** Session-less tool definition caches (no AgentSession state). */
-    operatorCustomToolsPromise;
+    operatorCustomToolsByMode = new Map();
     exploreCustomToolsPromise;
+    exploreOrchestrator;
     bindings;
     constructor(options) {
         this.options = options;
         this.loader = createOperatorChatResourceLoader();
         this.bindings = options.bindings ?? createDefaultPiSdkBindings();
+        this.exploreOrchestrator = new ExploreOrchestrator({
+            cwd: this.options.cwd,
+            bindings: this.bindings,
+            loadSafeExploreCustomTools: () => this.loadExploreCustomTools(),
+            // Fallback when the parent session's model is unknown at Agent-call
+            // time (e.g. turn started before materialization finished): resolve
+            // the default Chat model from the child services' modelRuntime.
+            resolveModel: async (modelRuntime) => {
+                const available = this.bindings.listAvailableModels({ modelRuntime });
+                const descriptor = await resolveDefaultChatModel(this.options.cwd, available);
+                if (!descriptor)
+                    return undefined;
+                return this.bindings.resolveModel({
+                    modelRuntime,
+                    provider: descriptor.provider,
+                    modelId: descriptor.modelId,
+                });
+            },
+        });
+    }
+    async syncAimaxAuthToken() {
+        await this.options.sddDataAlignment?.auth?.getToken();
     }
     /** Absolute path for repo-scoped resource preferences (may be undefined in unit tests). */
     get resourcePreferencesPath() {
@@ -1061,10 +1049,20 @@ export class ConsolePiRuntime {
      * after a PATCH sees the latest resource-preferences.json (not create-time
      * closure state).
      */
+    sessionModeOf(sessionId) {
+        if (!sessionId)
+            return DEFAULT_CONSOLE_CHAT_SESSION_MODE;
+        return this.sessionModes.get(sessionId) ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE;
+    }
+    rememberSessionMode(sessionId, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
+        this.sessionModes.set(sessionId, sessionMode);
+        return sessionMode;
+    }
     async buildResourceLoaderOptions(base = {}, sessionId) {
         const inheritedFactories = Array.isArray(base.extensionFactories)
             ? base.extensionFactories
             : [];
+        const sessionMode = this.sessionModeOf(sessionId);
         const todoContextExtension = sessionId && this.options.todoRegistry
             ? createTodoCompactionContextExtension({
                 sessionId,
@@ -1074,7 +1072,9 @@ export class ConsolePiRuntime {
         const pressureExtension = sessionId
             ? this.createContextPressureInlineExtension(sessionId)
             : undefined;
-        const goalContextExtension = sessionId && this.options.goalRegistry
+        const goalContextExtension = sessionId &&
+            this.options.goalRegistry &&
+            shouldInjectGoalContinuation(sessionMode)
             ? createGoalCompactionContextExtension({
                 sessionId,
                 registry: this.options.goalRegistry,
@@ -1320,8 +1320,10 @@ export class ConsolePiRuntime {
      * `initializing: true`; dependent routes wait on the same promise.
      */
     async createSession(init) {
+        await this.syncAimaxAuthToken();
         const sessionId = `operator-chat-${randomBytes(12).toString("hex")}`;
         this.disposedSessions.delete(sessionId);
+        const sessionMode = this.rememberSessionMode(sessionId, init?.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE);
         const sessionManager = await this.bindings.createSessionManager({
             cwd: this.options.cwd,
             sessionDir: this.options.sessionDir,
@@ -1347,6 +1349,7 @@ export class ConsolePiRuntime {
             sessionManager,
             model: init?.model,
             systemPromptSuffix: init?.systemPromptSuffix,
+            sessionMode,
             // Create path must resolve default model from the SAME services object
             // used for formal materialization (no throwaway createServices).
             resolveDefaultModel: !init?.model,
@@ -1356,7 +1359,8 @@ export class ConsolePiRuntime {
             sessionFile,
             createdAt: new Date().toISOString(),
             model: init?.model,
-            activeTools: OPERATOR_CHAT_ACTIVE_TOOL_NAMES(),
+            activeTools: chatActiveToolBaseline(sessionMode),
+            sessionMode,
             initializing: true,
         };
     }
@@ -1417,14 +1421,17 @@ export class ConsolePiRuntime {
     async materializeSession(sessionId, init) {
         if (this.disposedSessions.has(sessionId))
             return;
+        await this.syncAimaxAuthToken();
+        const sessionMode = this.rememberSessionMode(sessionId, init.sessionMode ?? this.sessionModeOf(sessionId));
         const agentDir = await safeGetAgentDir(this.bindings);
         // Capture before services parse models.json. A concurrent edit can therefore
         // cause at most one harmless extra refresh, never a missed next-turn refresh.
         const modelConfigFile = await captureModelConfigFile(agentDir);
-        const appendSystemPrompt = [
-            OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
-            ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
-        ];
+        const appendSystemPrompt = composeChatSystemPromptParts({
+            sessionMode,
+            workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+            systemPromptSuffix: init.systemPromptSuffix,
+        });
         // Single services construction for formal materialization (+ optional
         // default-model resolve from the same modelRuntime). Repo-scoped skill
         // auto-invocation prefs inject skillsOverride without touching SKILL.md.
@@ -1475,7 +1482,7 @@ export class ConsolePiRuntime {
             return;
         }
         await bindSessionExtensions(session);
-        pinOperatorChatTools(session);
+        pinOperatorChatTools(session, sessionMode);
         // Register then re-check dispose race: a concurrent dispose must win.
         this.sessions.set(sessionId, session);
         this.sessionManagers.set(sessionId, init.sessionManager);
@@ -1503,6 +1510,7 @@ export class ConsolePiRuntime {
             this.modelRuntimes.delete(sessionId);
             this.modelConfigFiles.delete(sessionId);
             this.sessionModels.delete(sessionId);
+            this.sessionModes.delete(sessionId);
             this.serviceScopes.delete(sessionId);
             this.revisions.delete(sessionId);
             this.thinkingSelections.delete(sessionId);
@@ -1510,8 +1518,12 @@ export class ConsolePiRuntime {
     }
     /** Cached session-less custom tool definitions (operator + explore). */
     async loadCustomTools(sessionId) {
+        const sessionMode = this.sessionModeOf(sessionId);
+        const loadWorkflowTools = shouldLoadWorkflowBusinessTools(sessionMode);
         const [operatorCustomTools, exploreCustomTools] = await Promise.all([
-            this.loadOperatorCustomTools(),
+            loadWorkflowTools
+                ? this.loadOperatorCustomTools(sessionMode)
+                : Promise.resolve([]),
             this.loadExploreCustomTools(),
         ]);
         const questionTool = this.options.questionRegistry
@@ -1521,33 +1533,77 @@ export class ConsolePiRuntime {
             })
             : undefined;
         const todoTool = this.options.todoRegistry
-            ? await buildTodoWriteTool({ sessionId, registry: this.options.todoRegistry })
+            ? await buildTodoWriteTool({
+                sessionId,
+                registry: this.options.todoRegistry,
+                sessionMode,
+            })
             : undefined;
-        const goalTools = this.options.goalRegistry
+        const goalTools = loadWorkflowTools && this.options.goalRegistry
             ? await buildGoalTools({ sessionId, registry: this.options.goalRegistry })
             : [];
+        const terminalTools = this.options.terminalRegistry
+            ? await buildPersistentTerminalTools({
+                ownerSessionId: sessionId,
+                registry: this.options.terminalRegistry,
+                defaultCwd: this.options.cwd,
+            }).catch((error) => {
+                process.stderr.write(`[console] chat terminal-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                return [];
+            })
+            : [];
+        const scmTools = this.options.scmService
+            ? await buildScmTools({ scm: this.options.scmService }).catch((error) => {
+                process.stderr.write(`[console] chat scm-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                return [];
+            })
+            : [];
+        const agentTool = await buildAgentCustomTool({
+            parentSessionId: sessionId,
+            orchestrator: this.exploreOrchestrator,
+            resolveModel: () => {
+                const model = this.sessionModels.get(sessionId);
+                const modelRuntime = this.modelRuntimes.get(sessionId);
+                if (!model || !modelRuntime)
+                    return undefined;
+                return this.bindings.resolveModel({
+                    modelRuntime,
+                    provider: model.provider,
+                    modelId: model.modelId,
+                });
+            },
+        }).catch((error) => {
+            process.stderr.write(`[console] chat Agent tool build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            return undefined;
+        });
         return [
             ...operatorCustomTools,
             ...exploreCustomTools,
             ...(questionTool ? [questionTool] : []),
             ...(todoTool ? [todoTool] : []),
             ...goalTools,
+            ...terminalTools,
+            ...scmTools,
+            ...(agentTool ? [agentTool] : []),
         ];
     }
-    loadOperatorCustomTools() {
+    loadOperatorCustomTools(sessionMode) {
         if (!this.options.actionContext)
             return Promise.resolve([]);
-        if (!this.operatorCustomToolsPromise) {
-            this.operatorCustomToolsPromise = buildCustomOperatorTools({
-                actionContext: this.options.actionContext,
-            }).catch((error) => {
-                process.stderr.write(`[console] chat custom-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
-                // Allow a later create/reopen to retry after a transient failure.
-                this.operatorCustomToolsPromise = undefined;
-                return [];
-            });
-        }
-        return this.operatorCustomToolsPromise;
+        const cached = this.operatorCustomToolsByMode.get(sessionMode);
+        if (cached)
+            return cached;
+        const promise = buildCustomOperatorTools({
+            actionContext: this.options.actionContext,
+            sessionMode,
+        }).catch((error) => {
+            process.stderr.write(`[console] chat custom-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            // Allow a later create/reopen to retry after a transient failure.
+            this.operatorCustomToolsByMode.delete(sessionMode);
+            return [];
+        });
+        this.operatorCustomToolsByMode.set(sessionMode, promise);
+        return promise;
     }
     loadExploreCustomTools() {
         if (!this.exploreCustomToolsPromise) {
@@ -1565,6 +1621,7 @@ export class ConsolePiRuntime {
         if (!this.bindings.forkSessionManager)
             throw new Error("SESSION_FORK_UNSUPPORTED");
         const sessionId = `operator-chat-${randomBytes(12).toString("hex")}`;
+        const sessionMode = this.rememberSessionMode(sessionId, init.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE);
         const sessionManager = await this.bindings.forkSessionManager({
             sourcePath: init.sourceSessionFile,
             targetCwd: this.options.cwd,
@@ -1575,8 +1632,8 @@ export class ConsolePiRuntime {
             sessionId,
             sessionManager,
             model: init.model,
+            sessionMode,
         });
-        built.session.setActiveToolsByName(computeOperatorChatActiveToolNames(built.session));
         this.sessions.set(sessionId, built.session);
         this.sessionManagers.set(sessionId, sessionManager);
         this.modelRuntimes.set(sessionId, built.modelRuntime);
@@ -1592,6 +1649,7 @@ export class ConsolePiRuntime {
             createdAt: new Date().toISOString(),
             model: init.model,
             activeTools: built.session.getActiveToolNames(),
+            sessionMode,
         };
     }
     async branchSession(input) {
@@ -1770,15 +1828,22 @@ export class ConsolePiRuntime {
     async getRuntimeSystemPrompt(sessionId) {
         await this.ensureSessionReady(sessionId).catch(() => undefined);
         const session = this.sessions.get(sessionId);
-        if (!session)
-            return composeOperatorChatSystemPrompt({});
+        if (!session) {
+            return composeChatSystemPrompt({
+                sessionMode: this.sessionModeOf(sessionId),
+                workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+            });
+        }
         const fromState = session.state?.systemPrompt;
         const fromGetter = session.systemPrompt;
         const loader = this.serviceScopes.get(sessionId)?.resourceLoader;
         return (fromState ||
             fromGetter ||
             loader?.getSystemPrompt?.() ||
-            composeOperatorChatSystemPrompt({}));
+            composeChatSystemPrompt({
+                sessionMode: this.sessionModeOf(sessionId),
+                workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+            }));
     }
     /**
      * Read the RAW system prompt for the snapshot, converting any projection
@@ -1871,6 +1936,7 @@ export class ConsolePiRuntime {
             if (services)
                 this.applySessionCompactionOverride(sessionId, services, session);
             await this.refreshModelConfiguration(sessionId, "force");
+            pinOperatorChatTools(session, this.sessionModeOf(sessionId));
         }
         catch (error) {
             return {
@@ -2307,7 +2373,9 @@ export class ConsolePiRuntime {
      * than silently creating a fresh empty session and losing prior context.
      */
     async reopenSession(init) {
+        await this.syncAimaxAuthToken();
         const sessionId = init.sessionId;
+        const sessionMode = this.rememberSessionMode(sessionId, init.sessionMode ?? this.sessionModeOf(sessionId));
         // Wait for in-flight create materialization rather than racing reopen.
         const initState = this.sessionInit.get(sessionId);
         if (initState?.status === "initializing") {
@@ -2384,6 +2452,7 @@ export class ConsolePiRuntime {
                 sessionManager,
                 model: init.model,
                 systemPromptSuffix: init.systemPromptSuffix,
+                sessionMode,
             });
             const session = built.session;
             // Prefer the SessionManager id (from the JSONL header). Some SDK
@@ -2406,7 +2475,6 @@ export class ConsolePiRuntime {
                     message: `reopened Pi sessionId mismatch: expected ${sessionId}, got ${reportedId}`,
                 };
             }
-            session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
             this.sessions.set(sessionId, session);
             this.sessionManagers.set(sessionId, sessionManager);
             this.modelRuntimes.set(sessionId, built.modelRuntime);
@@ -2424,6 +2492,7 @@ export class ConsolePiRuntime {
                     createdAt: new Date().toISOString(),
                     model: init.model,
                     activeTools: session.getActiveToolNames(),
+                    sessionMode,
                 },
             };
         }
@@ -2455,6 +2524,7 @@ export class ConsolePiRuntime {
             createdAt: new Date().toISOString(),
             model,
             activeTools: session.getActiveToolNames(),
+            sessionMode: this.sessionModeOf(sessionId),
         };
     }
     /**
@@ -2463,12 +2533,14 @@ export class ConsolePiRuntime {
      * before AgentSession is ready. Tool definitions reuse runtime-level caches.
      */
     async buildSessionWithServices(init) {
+        const sessionMode = this.rememberSessionMode(init.sessionId, init.sessionMode ?? this.sessionModeOf(init.sessionId));
         const agentDir = await safeGetAgentDir(this.bindings);
         const modelConfigFile = await captureModelConfigFile(agentDir);
-        const appendSystemPrompt = [
-            OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
-            ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
-        ];
+        const appendSystemPrompt = composeChatSystemPromptParts({
+            sessionMode,
+            workflowPrompt: OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
+            systemPromptSuffix: init.systemPromptSuffix,
+        });
         await this.refreshSkillPrefsCache().catch(() => undefined);
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
@@ -2493,7 +2565,7 @@ export class ConsolePiRuntime {
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
         await bindSessionExtensions(session);
-        pinOperatorChatTools(session);
+        pinOperatorChatTools(session, sessionMode);
         this.applySessionCompactionOverride(init.sessionId, services, session);
         return {
             session,
@@ -2562,7 +2634,7 @@ export class ConsolePiRuntime {
     }
     /**
      * Send a prompt and stream events. Gate 3: each tool invocation is
-     * re-authorized by authorizeOperatorChatTool before the dispatcher runs it
+     * re-authorized by authorizeChatSessionTool(mode) before the dispatcher runs it
      * (the dispatcher is wired by the HTTP layer, see chat-session.ts).
      *
      * Prompt ownership is acquired synchronously before the first await so two
@@ -2595,6 +2667,7 @@ export class ConsolePiRuntime {
             catch {
                 // ignore
             }
+            void this.exploreOrchestrator.abortByParent(sessionId);
         };
         try {
             if (options?.turnId && this.options.questionRegistry) {
@@ -2603,7 +2676,8 @@ export class ConsolePiRuntime {
             if (options?.turnId && this.options.todoRegistry) {
                 this.options.todoRegistry.startTurn(sessionId, options.turnId);
             }
-            if (this.options.goalRegistry) {
+            if (this.options.goalRegistry &&
+                shouldInjectGoalContinuation(this.sessionModeOf(sessionId))) {
                 this.options.goalRegistry.startTurn(sessionId, text);
             }
             // AC-FIX-002: if Stop already fired before readiness, never start model work.
@@ -2624,10 +2698,11 @@ export class ConsolePiRuntime {
             // existing closed interview allow/deny registry. The next ordinary turn
             // explicitly restores the normal Operator Chat set (baseline + extension
             // tools, ADR 0012).
-            const requestedTools = OPERATOR_CHAT_ACTIVE_TOOL_NAMES();
-            const activeTools = options?.mode === "requirement-interview"
+            const sessionMode = this.sessionModeOf(sessionId);
+            const requestedTools = chatActiveToolBaseline(sessionMode);
+            const activeTools = options?.mode === "requirement-interview" && sessionMode === "workflow"
                 ? filterActiveInterviewTools(requestedTools).allowed
-                : computeOperatorChatActiveToolNames(session);
+                : computeChatActiveToolNames(session, sessionMode);
             session.setActiveToolsByName(activeTools);
             // Final pre-prompt fence: abort after tool pin must still skip session.prompt.
             if (options?.signal?.aborted) {
@@ -2965,15 +3040,18 @@ export class ConsolePiRuntime {
         this.modelRuntimes.delete(sessionId);
         this.modelConfigFiles.delete(sessionId);
         this.sessionModels.delete(sessionId);
+        this.sessionModes.delete(sessionId);
         this.serviceScopes.delete(sessionId);
         this.revisions.delete(sessionId);
         this.thinkingSelections.delete(sessionId);
         this.reloadInFlight.delete(sessionId);
         this.pendingSteering.delete(sessionId);
+        void this.exploreOrchestrator.abortByParent(sessionId);
     }
     disposeAll() {
         for (const id of [...this.sessions.keys()])
             this.dispose(id);
+        void this.exploreOrchestrator.abortAll();
     }
 }
 function mapAssistantMessageEvent(type, sessionId, message) {
@@ -3278,7 +3356,8 @@ export function createDefaultPiSdkBindings() {
     };
 }
 /**
- * Re-export the tool gate for the dispatcher layer so the per-tool-call gate
- * (Gate 3) lives in exactly one place.
+ * Re-export the tool gates for the dispatcher layer so the per-tool-call gate
+ * (Gate 3) lives in exactly one place. authorizeChatSessionTool is the
+ * mode-aware gate; the legacy name stays for workflow-only callers.
  */
-export { authorizeOperatorChatTool, assertNoWriteToolInList, OPERATOR_CHAT_ALLOWED_TOOLS, };
+export { authorizeChatSessionTool, authorizeOperatorChatTool, assertNoWriteToolInList, OPERATOR_CHAT_ALLOWED_TOOLS, };

package/dist/worker/console/chat/resource-loader.js

@@ -15,7 +15,7 @@
  * The three-gate authorization (authorizeOperatorChatTool) is the actual
  * enforcement; this adapter describes what that gate admits.
  */
-import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, OPERATOR_CHAT_PI_BUILTIN_TOOLS, authorizeOperatorChatTool, filterOperatorChatTools, assertNoWriteToolInList, } from "./tools.js";
+import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, OPERATOR_CHAT_PI_BUILTIN_TOOLS, OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS, authorizeOperatorChatTool, filterOperatorChatTools, assertNoWriteToolInList, } from "./tools.js";
 /** Built-in Pi tool names allowed in every Chat session (ADR 0011). */
 export const OPERATOR_CHAT_BUILTIN_EXPLORE_TOOL_IDS = Object.freeze([
     ...OPERATOR_CHAT_PI_BUILTIN_TOOLS,
@@ -42,6 +42,9 @@ export function createOperatorChatResourceLoader() {
             if (explore) {
                 return { ok: true, toolId };
             }
+            if (OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS.includes(toolId)) {
+                return { ok: true, toolId };
+            }
             const decision = authorizeOperatorChatTool(toolId);
             if (decision.ok)
                 active.add(decision.toolId);