@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.19

package/dist/worker/console/chat/pi-runtime/custom-tools/operator-tools.js

@@ -3,6 +3,8 @@
  * Definitions and execute() live here; ConsolePiRuntime owns caching and
  * composition with session-bound tools.
  */
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { scheduledGoalBookingSchema } from "../../scheduled-goal-booking.js";
 import { authorizeChatSessionTool, DEFAULT_CONSOLE_CHAT_SESSION_MODE, } from "../../session-mode.js";
 import { buildModelCallableToolSchemas } from "../../tool-adapter.js";
 /**
@@ -17,7 +19,7 @@ export async function buildCustomOperatorTools(options) {
         import("typebox"),
         import("@earendil-works/pi-coding-agent"),
     ]);
-    const schemas = buildModelCallableToolSchemas();
+    const schemas = buildModelCallableToolSchemas().filter((schema) => schema.toolId !== "prepareScheduledTask");
     const ctx = options.actionContext;
     return schemas.map((schema) => {
         // TypeBox schema is built dynamically; cast through unknown to the builder
@@ -29,22 +31,28 @@ export async function buildCustomOperatorTools(options) {
                 ? { description: param.description }
                 : {};
             let t;
-            switch (param.type) {
-                case "string":
-                    t = Type.String(desc);
-                    break;
-                case "boolean":
-                    t = Type.Boolean(desc);
-                    break;
-                case "number":
-                    t = Type.Number(desc);
-                    break;
-                case "array":
-                    t = Type.Array(Type.String({}), Object.keys(desc).length ? desc : {});
-                    break;
-                default:
-                    t = Type.Object({}, { additionalProperties: true });
+            if (schema.toolId === "prepareScheduledGoal" && param.name === "booking") {
+                // Provider adapters need every nested type (not an opaque object).
+                // Keep the strict service schema as the single input contract.
+                t = zodToJsonSchema(scheduledGoalBookingSchema, { $refStrategy: "none" });
             }
+            else
+                switch (param.type) {
+                    case "string":
+                        t = Type.String(desc);
+                        break;
+                    case "boolean":
+                        t = Type.Boolean(desc);
+                        break;
+                    case "number":
+                        t = Type.Number(desc);
+                        break;
+                    case "array":
+                        t = Type.Array(Type.String({}), Object.keys(desc).length ? desc : {});
+                        break;
+                    default:
+                        t = Type.Object({}, { additionalProperties: true });
+                }
             acc[param.name] = param.required ? t : Type.Optional(t);
             return acc;
         }, {}), { additionalProperties: false });

package/dist/worker/console/chat/pi-runtime/custom-tools/scheduled-goal-tools.js

@@ -0,0 +1,22 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { scheduledTaskRequestSchema } from "../../scheduled-goal-request.js";
+import { buildModelCallableToolSchemas } from "../../tool-adapter.js";
+/** Host-bound identity is not a model parameter and cannot leak across sessions. */
+export async function buildScheduledGoalTools(options) {
+    const { Type } = await import("typebox");
+    const { defineTool } = await import("@earendil-works/pi-coding-agent");
+    const schema = buildModelCallableToolSchemas().find((tool) => tool.action === "prepareScheduledTask");
+    if (!schema)
+        throw new Error("scheduled task capability missing");
+    return [defineTool({
+            name: schema.toolId, label: "准备定时任务", description: schema.description, promptSnippet: schema.description,
+            parameters: Type.Object({ request: zodToJsonSchema(scheduledTaskRequestSchema, { $refStrategy: "none" }) }, { additionalProperties: false }),
+            async execute(callId, params) {
+                const { dispatchChatToolCall } = await import("../../session-store.js");
+                const result = await dispatchChatToolCall({ ...options.actionContext, chatSessionRef: options.sessionId }, schema.toolId, params, callId, "workflow");
+                const value = result.ok ? result.result : { ok: false, error: result.message, code: result.errorCode,
+                    nextAction: "Correct the business request and retry prepareScheduledTask. Do not edit PRD/runtime files, substitute sleep/immediate execution, or claim a booking exists." };
+                return { isError: !result.ok, content: [{ type: "text", text: JSON.stringify(value) }], details: value };
+            },
+        })];
+}

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

@@ -0,0 +1,195 @@
+/** Model exposure only. Capability registry and dispatch remain the authority. */
+import { Type } from "typebox";
+import { buildModelCallableToolSchemas } from "../tool-adapter.js";
+import { computeChatActiveToolNames } from "../session-mode.js";
+import { filterActiveInterviewTools } from "../../interview/tools.js";
+export const TOOL_EXPOSURE_ENTRY = "console-tool-exposure";
+export const TOOL_CATALOG_VERSION = 1;
+export const CORE_WORKFLOW_TOOLS = Object.freeze(`prepareScheduledTask scheduledGoalGet scheduledGoalList newTask importPrd sourceInstructions contractDraftSave contractShow contractValidate contractDiff taskAdvance prepareDagConfirmation prepareDagExecution runDag operationGet operationList operationEventSummary operationWait observeLink dagReport dagDoctor dagRerunPlan dagRerun prepareMutationGate standaloneTaskRerun workerTaskRetry status planList operatorCapabilities`.split(" "));
+const SCHEDULED_BOOKING_READ_TOOLS = new Set(["read", "find", "ls", "grep"]);
+export function isScheduledBookingTurn(text) {
+    return /(?:预约|定时|稍后|分钟后|小时后|schedule(?:d)?|\blater\b)/i.test(text);
+}
+/** Keep booking turns on typed workflow actions and local read-only inspection. */
+export function pinScheduledBookingTurnTools(session) {
+    const allowed = session.getActiveToolNames().filter(name => CORE_WORKFLOW_TOOLS.includes(name) || SCHEDULED_BOOKING_READ_TOOLS.has(name));
+    session.setActiveToolsByName(allowed);
+    return allowed;
+}
+export const WORKFLOW_TOOL_GROUPS = [
+    { id: "scheduling", examples: ["prepareScheduledGoal"], description: "高级预约：已有 DAG/Task 的冻结预约", tools: ["prepareScheduledGoal"] },
+    { id: "diagnostics", examples: ["inspect", "doctor", "dagValidate"], description: "DAG 深度诊断、校验、决策、上下文与初始化检查", tools: ["inspect", "doctor", "statsContext", "spineCheck", "dagRunTask", "dagValidate", "dagPromptOverrideConfig", "dagInterruptEligibility", "dagStatus", "dagDecisionInspect", "dagDecisionValidate"] },
+    { id: "governance", examples: ["planCreate", "docsAudit", "closeoutTask"], description: "计划管理、文档审计、交接覆盖与任务收口", tools: ["planCreate", "planComplete", "planCheck", "docsAudit", "handoffCheck", "handoffCoverage", "coverageReport", "stats", "promoteRun", "closeoutTask", "dagCloseoutDraft"] },
+    { id: "knowledge", examples: ["knowledgeQuery"], description: "查询项目知识", tools: ["knowledgeQuery"] },
+    { id: "worker", examples: ["workerSchedulerStatus", "workerPoolDoctor", "workerReportMorning"], description: "Worker 任务池、功能审查、调度诊断与报表", tools: ["workerPoolDoctor", "workerFeatureReview", "workerFeatureDoctor", "workerTaskValidate", "workerBatchPlanReady", "workerReportMorning", "workerReportMetrics", "workerAdmissionShow", "workerSchedulerList", "workerSchedulerStatus", "workerSchedulerLedger", "workerSchedulerDoctor"] },
+];
+export function configuredToolExposure(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (value === "full" || value === "progressive")
+        return value;
+    throw new Error("CONSOLE_CHAT_TOOL_EXPOSURE must be full or progressive");
+}
+/** Fail closed on catalog drift, including duplicate or human-only entries. */
+export function validateWorkflowToolCatalog() {
+    const expected = new Set(buildModelCallableToolSchemas().map(t => t.toolId));
+    const names = [...CORE_WORKFLOW_TOOLS, ...WORKFLOW_TOOL_GROUPS.flatMap(g => [...g.tools])];
+    if (names.length !== new Set(names).size || names.length !== expected.size || names.some(n => !expected.has(n)))
+        throw new Error("WORKFLOW_TOOL_CATALOG_DRIFT");
+}
+export const TOOL_DISCOVERY_DESCRIPTION = "Load a workflow capability missing from the visible tools. Choose target by the user's intent from the capability directory, even when no tool name was mentioned. Pass a group ID or exact tool name; omit target if unsure. After loading, call the matching typed tool in the NEXT model response. Discovery alone does not fulfill the request, execute work or grant approval. Prefer discovery over recreating a workflow with shell or file edits.";
+export class WorkflowToolExposure {
+    override;
+    state;
+    session;
+    interview = false;
+    manager;
+    // Failed persistence must not let the next turn silently undo full fallback.
+    // The active branch must still contain this ancestor; sibling branches do not inherit it.
+    volatileFallback;
+    constructor(manager, override) {
+        this.override = override;
+        this.manager = (manager ?? {});
+        this.state = { version: TOOL_CATALOG_VERSION, mode: override ?? "full", groups: [] };
+        try {
+            this.restore();
+        }
+        catch {
+            this.state = { version: TOOL_CATALOG_VERSION, mode: "full", groups: [], fallbackReason: "TOOL_EXPOSURE_STATE_READ_FAILED" };
+        }
+    }
+    get mode() { return this.state.mode; }
+    get snapshot() { return { ...this.state, groups: [...this.state.groups] }; }
+    restore() {
+        const entries = this.manager.getBranch?.() ?? [];
+        const latest = entries.filter(e => e.type === "custom" && e.customType === TOOL_EXPOSURE_ENTRY).at(-1);
+        if (!latest) {
+            this.state = { version: TOOL_CATALOG_VERSION, mode: this.override ?? "full", groups: [] };
+            return;
+        }
+        const raw = latest.data;
+        if (raw?.version !== TOOL_CATALOG_VERSION || !["full", "progressive"].includes(raw.mode ?? "") || !Array.isArray(raw.groups) || raw.groups.some(id => !WORKFLOW_TOOL_GROUPS.some(g => g.id === id))) {
+            this.state = { version: TOOL_CATALOG_VERSION, mode: "full", groups: [], fallbackReason: "INVALID_SAVED_TOOL_EXPOSURE" };
+            return;
+        }
+        const mode = raw.mode === "full" && raw.fallbackReason ? "full" : (this.override ?? raw.mode);
+        this.state = { version: TOOL_CATALOG_VERSION, mode, groups: [...new Set(raw.groups)], ...(mode === "full" && raw.fallbackReason ? { fallbackReason: raw.fallbackReason } : {}) };
+    }
+    persist() {
+        if (!this.manager.appendCustomEntry || !this.manager.getBranch)
+            throw new Error("TOOL_EXPOSURE_PERSISTENCE_UNAVAILABLE");
+        const previous = this.manager.getBranch().filter(e => e.type === "custom" && e.customType === TOOL_EXPOSURE_ENTRY).at(-1)?.data;
+        if (JSON.stringify(previous) !== JSON.stringify(this.state))
+            this.manager.appendCustomEntry(TOOL_EXPOSURE_ENTRY, this.snapshot);
+    }
+    exposed() {
+        if (this.state.mode === "full")
+            return undefined;
+        return [...CORE_WORKFLOW_TOOLS, ...WORKFLOW_TOOL_GROUPS.filter(g => this.state.groups.includes(g.id)).flatMap(g => [...g.tools])];
+    }
+    apply() {
+        if (!this.session)
+            throw new Error("TOOL_EXPOSURE_SESSION_UNAVAILABLE");
+        const names = computeChatActiveToolNames(this.session, "workflow", this.exposed());
+        const allowed = this.interview ? filterActiveInterviewTools(names).allowed : names;
+        this.session.setActiveToolsByName(allowed);
+        // SDK silently ignores unknown names: verify actual registration, not intent.
+        if (this.session.getAllTools) {
+            const registered = new Set(this.session.getAllTools().map(t => t.name));
+            const actual = new Set(this.session.getActiveToolNames());
+            const required = this.interview ? [] : (this.exposed() ?? CORE_WORKFLOW_TOOLS);
+            if (required.some(name => !registered.has(name) || !actual.has(name)))
+                throw new Error("TOOL_EXPOSURE_REQUIRED_TOOL_MISSING");
+            if (allowed.some(n => registered.has(n) && !actual.has(n)) || [...actual].some(n => !allowed.includes(n)))
+                throw new Error("TOOL_EXPOSURE_ACTIVATION_MISMATCH");
+        }
+    }
+    fallback(reason) {
+        this.state = { version: TOOL_CATALOG_VERSION, mode: "full", groups: [], fallbackReason: reason };
+        this.apply(); // A failure here is fatal; never pretend full mode is active.
+        try {
+            this.persist();
+            this.volatileFallback = undefined;
+        }
+        catch {
+            let anchor;
+            try {
+                anchor = this.manager.getBranch?.().at(-1);
+            }
+            catch { /* Conservatively keep full when branch cannot be read. */ }
+            this.volatileFallback = { anchor, state: this.snapshot };
+        }
+    }
+    pin(session, interview = false) {
+        this.session = session;
+        this.interview = interview;
+        // Reconstruct from the active branch, including after compaction/reopen.
+        try {
+            const pending = this.volatileFallback;
+            const branch = this.manager.getBranch?.() ?? [];
+            if (pending && (!pending.anchor || branch.some(entry => entry === pending.anchor ||
+                (pending.anchor?.id !== undefined && entry.id === pending.anchor.id)))) {
+                this.state = { ...pending.state, groups: [...pending.state.groups] };
+            }
+            else {
+                this.volatileFallback = undefined;
+                this.restore();
+            }
+            validateWorkflowToolCatalog();
+            this.apply();
+            // Full mode also records the session policy when supported.
+            if (this.mode === "progressive" || this.manager.appendCustomEntry) {
+                this.persist();
+                this.volatileFallback = undefined;
+            }
+        }
+        catch {
+            this.fallback(this.state.fallbackReason ?? "TOOL_EXPOSURE_RESTORE_OR_ACTIVATION_FAILED");
+        }
+    }
+    discover(target) {
+        if (this.interview)
+            return { ok: false, code: "TOOL_DISCOVERY_INTERVIEW_DENIED" };
+        const catalog = WORKFLOW_TOOL_GROUPS.map(g => ({ id: g.id, description: g.description, examples: [...g.examples], active: this.mode === "full" || this.state.groups.includes(g.id) }));
+        if (!target)
+            return { ok: true, ...this.snapshot, catalog };
+        if (CORE_WORKFLOW_TOOLS.includes(target)) {
+            if (!this.session?.getActiveToolNames().includes(target))
+                return { ok: false, code: "TOOL_EXPOSURE_REQUIRED_TOOL_MISSING" };
+            return { ok: true, alreadyActive: true, tools: [target] };
+        }
+        const group = WORKFLOW_TOOL_GROUPS.find(g => g.id === target || g.tools.includes(target));
+        if (!group)
+            return { ok: false, code: "TOOL_DISCOVERY_NOT_FOUND", catalog };
+        if (!this.session)
+            return { ok: false, code: "TOOL_EXPOSURE_SESSION_UNAVAILABLE" };
+        const registered = new Set(this.session.getAllTools?.().map(t => t.name) ?? []);
+        if (group.tools.some(n => !registered.has(n))) {
+            this.fallback("TOOL_EXPOSURE_GROUP_UNAVAILABLE");
+            return { ok: false, code: "TOOL_EXPOSURE_GROUP_UNAVAILABLE", ...this.snapshot };
+        }
+        try {
+            this.state = { ...this.state, groups: [...new Set([...this.state.groups, group.id])] };
+            this.apply();
+            this.persist();
+        }
+        catch {
+            this.fallback("TOOL_EXPOSURE_LOAD_FAILED");
+        }
+        return { ok: true, ...this.snapshot, group: group.id, tools: [...group.tools], effective: "next-model-response", guidance: "Use the activated typed tools in your next response. Loading has not executed any business action." };
+    }
+    buildTool(fullTool) {
+        return { name: "operatorCapabilities", label: "发现工作流工具", description: TOOL_DISCOVERY_DESCRIPTION,
+            // One short navigation line; detailed semantics live in schema description.
+            promptSnippet: "工作流能力目录：按用户意图选组；所需能力未显示时先调用 operatorCapabilities(target=组ID)，再调用加载后的业务工具完成请求：" + WORKFLOW_TOOL_GROUPS.map(g => `${g.id}: ${g.description} (${g.examples.join(", ")})`).join("; "),
+            parameters: Type.Object({ target: Type.Optional(Type.String({ maxLength: 80, description: "Group ID or exact tool name; omit to list groups." })) }, { additionalProperties: false }),
+            execute: async (_id, params, signal) => {
+                if (signal?.aborted)
+                    throw new Error("Tool discovery aborted");
+                if (this.mode === "full" && !this.interview && !params.target && fullTool)
+                    return fullTool.execute(_id, {});
+                const result = this.discover(params.target);
+                return { isError: result.ok === false, content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+            } };
+    }
+}

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

@@ -37,6 +37,7 @@ import { authorizeChatSessionTool, DEFAULT_CONSOLE_CHAT_SESSION_MODE, chatActive
 import { buildAgentCustomTool, ExploreOrchestrator, } from "./subagents/index.js";
 import { createOperatorChatResourceLoader, } from "./resource-loader.js";
 import { applySkillAutoInvocationPreferences, loadResourcePreferences, } from "./resource-preferences-store.js";
+import { buildPiModeLoopIsolationOptions } from "./pi-mode-loop-isolation.js";
 import { applyProcessRetryOverride, } from "../../../shared/pi-retry-settings.js";
 import { applyProcessCompactionOverride, createCompactionController, createContextPressureExtension, createSiftBridgeState, housekeepSiftStash, isConsoleSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, projectPromptPressure, deriveEffectiveWindow, projectSafeTelemetry, emptyContextPressureCounters, } from "../../../shared/pi-context-pressure/index.js";
 import { incrementCounter as incrementPressureCounter } from "../../../shared/pi-context-pressure/telemetry.js";
@@ -49,6 +50,8 @@ import { buildPersistentTerminalTools } from "./terminal-tools.js";
 import { buildScmTools } from "./scm-tools.js";
 import { buildGoalContinuationContext, } from "./goals.js";
 import { injectWizardLocalHeaders, } from "./sdd-data-alignment.js";
+import { buildScheduledGoalTools } from "./pi-runtime/custom-tools/scheduled-goal-tools.js";
+import { WorkflowToolExposure, configuredToolExposure, isScheduledBookingTurn, pinScheduledBookingTurnTools, } from "./pi-runtime/progressive-tools.js";
 import { buildCustomOperatorTools } from "./pi-runtime/custom-tools/operator-tools.js";
 import { buildBrowserTools } from "./pi-runtime/custom-tools/browser-tools.js";
 import { buildAskUserQuestionTool } from "./pi-runtime/custom-tools/ask-user-question.js";
@@ -80,13 +83,14 @@ import { createDefaultPiSdkBindings, safeGetAgentDir, } from "./pi-runtime/sdk-b
  */
 export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "You are General Operator Chat.",
-    "Use operator tools first (dagReport, dagRerunPlan, dagRerun). Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for probes. Browser_* drives the visible Browser panel only (static http(s), no workspace edits/scripts).",
+    "For workflow requests use operator tools; discover missing capabilities via operatorCapabilities(target). Obey AGENTS.md. Deny apply_patch/full-tools/shell/coding-chat; probe with safe-read/safe-grep. Browser_*: visible Browser panel only (static http(s), no workspace edits/scripts).",
     "No harness and asked to init: `loop-agent init instructions --repo-root .`, then `loop-agent init --repo-root . --profile full --merge`; verify with doctor, inspect and docs audit. Updates: `loop-agent init upgrade --repo-root . --json` until stable; `loop-agent init check-update` is read-only.",
+    "Scheduled intent takes precedence over task content: prepareScheduledTask first; no curl/HTTP probes or tests; never perform the scheduled work now. Only a planned goalId means booked; never self-confirm.",
     "Long DAGs: prepareDagExecution → runDag → operationId. Never foreground-Bash task advance, tail/head pipes or nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise operationGet/status/dagReport/dagDoctor/operationWait at 60s → 90s → 120s → 180s; reset to 60s on state change; 30-60s re-checks when stall suspected. operationWait MUST use afterSeq=previous nextSeq (recommendedNextCall). Heartbeats: not meaningful progress. Run id ≠ task id.",
-    "Failure: terminal runSummary first. With progress wait; else dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun: reruns the failed subgraph, keeps prior successes. Ineligible: Worker → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). Do not call dagResume; do not re-advance a run-failed task. Pre-run identical state twice: stop and report; never loop identical bash/read/grep. Approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
-    "Iterate toward the goal in bounded rounds: first summarize the previous round's error in one line, fix its root cause — not the symptom — then rerun the failed node with a fresh plan. Never resubmit an unchanged fix; after two rounds failing the same way, stop and report evidence and remaining routes.",
-    "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.",
+    "Failure: dagReport(runId) → terminal runSummary. With progress wait; else dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun: reruns the failed subgraph, keeps prior successes. Ineligible: Worker → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). No dagResume or re-advance of run-failed tasks. Pre-run identical state twice: stop and report; never loop identical bash/read/grep. Approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
+    "Each bounded round: summarize the previous round's error in one line, fix its root cause — not the symptom — then rerun the failed node with a fresh plan. Never resubmit an unchanged fix; after two rounds failing the same way, stop and report evidence and remaining routes.",
+    "Continue until success, user stop, or no safe recovery remains. Never create a new task for a transient failure or replace repair-pi with direct edits.",
+    "Report start, meaningful phase changes, failures, prolonged quiet and completion: what finished and what is next. Never narrate unchanged operationWait polls or heartbeats.",
 ].join("\n");
 /**
  * Built-in SDK tool names registered for every Chat session (ADR 0011).
@@ -387,6 +391,7 @@ export class ConsolePiRuntime {
     /** Non-sensitive models.json metadata used to avoid reparsing unchanged config. */
     modelConfigFiles = new Map();
     sessionManagers = new Map();
+    toolExposures = new Map();
     /** Per-session SDK service scope (resourceLoader / settingsManager) used by the live runtime snapshot. */
     serviceScopes = new Map();
     /** Snapshot revision: bumped on create / reopen / model / thinking / reload. */
@@ -418,11 +423,17 @@ export class ConsolePiRuntime {
     exploreOrchestrator;
     bindings;
     browserAutomation;
+    ownsBrowserAutomation;
     constructor(options) {
         this.options = options;
         this.loader = createOperatorChatResourceLoader();
         this.bindings = options.bindings ?? createDefaultPiSdkBindings();
-        this.browserAutomation = options.browserAutomation ?? new BrowserAutomationService();
+        this.ownsBrowserAutomation = options.browserAutomation === undefined;
+        this.browserAutomation = options.browserAutomation ?? new BrowserAutomationService({
+            profileDir: path.join(this.options.sessionDir, "..", "browser-profile"),
+            downloadsDir: path.join(this.options.sessionDir, "..", "browser-downloads"),
+            screenshotsDir: path.join(this.options.sessionDir, "..", "browser-screenshots"),
+        });
         this.exploreOrchestrator = new ExploreOrchestrator({
             cwd: this.options.cwd,
             bindings: this.bindings,
@@ -483,7 +494,7 @@ export class ConsolePiRuntime {
         this.sessionModes.set(sessionId, sessionMode);
         return sessionMode;
     }
-    async buildResourceLoaderOptions(base = {}, sessionId) {
+    async buildResourceLoaderOptions(base = {}, sessionId, sessionMode = DEFAULT_CONSOLE_CHAT_SESSION_MODE) {
         const inheritedFactories = Array.isArray(base.extensionFactories)
             ? base.extensionFactories
             : [];
@@ -514,6 +525,7 @@ export class ConsolePiRuntime {
             pressureExtension,
             wizardLocalHeadersExtension,
         ].filter((item) => Boolean(item));
+        const piMode = sessionMode === "pi";
         return {
             ...base,
             ...(extraFactories.length > 0
@@ -521,18 +533,23 @@ export class ConsolePiRuntime {
                     extensionFactories: [...inheritedFactories, ...extraFactories],
                 }
                 : {}),
-            skillsOverride: (current) => {
+            ...buildPiModeLoopIsolationOptions({
+                enabled: piMode,
+                cwd: this.options.cwd,
                 // Synchronous override surface: use last-known prefs via a sync
                 // fail-closed path. Prefer async cache filled by ensurePrefs.
-                const prefs = this.cachedSkillPrefs ?? {
-                    schemaVersion: 1,
-                    skills: {},
-                };
-                return {
-                    skills: applySkillAutoInvocationPreferences(current.skills, prefs),
-                    diagnostics: current.diagnostics,
-                };
-            },
+                readPreferences: () => this.cachedSkillPrefs,
+                skillsOverride: (current) => {
+                    const prefs = this.cachedSkillPrefs ?? {
+                        schemaVersion: 1,
+                        skills: {},
+                    };
+                    return {
+                        skills: applySkillAutoInvocationPreferences(current.skills, prefs),
+                        diagnostics: current.diagnostics,
+                    };
+                },
+            }),
         };
     }
     /** Last successfully loaded skill prefs (sync override + snapshot projection). */
@@ -852,6 +869,9 @@ export class ConsolePiRuntime {
         const aborted = () => Boolean(init.abortIfDisposed && this.disposedSessions.has(init.sessionId));
         if (aborted())
             return undefined;
+        if (init.sessionMode === "workflow" && this.options.actionContext) {
+            this.toolExposures.set(init.sessionId, new WorkflowToolExposure(init.sessionManager, this.options.toolExposure ?? configuredToolExposure(process.env.CONSOLE_CHAT_TOOL_EXPOSURE)));
+        }
         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.
@@ -865,7 +885,7 @@ export class ConsolePiRuntime {
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: await this.buildResourceLoaderOptions({ appendSystemPrompt }, init.sessionId),
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({ appendSystemPrompt }, init.sessionId, init.sessionMode),
         });
         if (aborted())
             return undefined;
@@ -907,8 +927,19 @@ export class ConsolePiRuntime {
             }
             return undefined;
         }
-        await bindSessionExtensions(session);
-        pinOperatorChatTools(session, init.sessionMode);
+        try {
+            await bindSessionExtensions(session);
+            this.pinSessionTools(init.sessionId, session);
+        }
+        catch (error) {
+            try {
+                session.dispose();
+            }
+            finally {
+                this.toolExposures.delete(init.sessionId);
+            }
+            throw error;
+        }
         this.applySessionRecoveryOverrides(init.sessionId, services, session);
         return {
             session,
@@ -957,6 +988,7 @@ export class ConsolePiRuntime {
             }
             this.sessions.delete(sessionId);
             this.sessionManagers.delete(sessionId);
+            this.toolExposures.delete(sessionId);
             this.modelRuntimes.delete(sessionId);
             this.modelConfigFiles.delete(sessionId);
             this.sessionModels.delete(sessionId);
@@ -966,6 +998,20 @@ export class ConsolePiRuntime {
             this.thinkingSelections.delete(sessionId);
         }
     }
+    pinSessionTools(sessionId, session, interview = false) {
+        const exposure = this.toolExposures.get(sessionId);
+        if (exposure) {
+            exposure.pin(session, interview);
+            return;
+        }
+        if (interview) {
+            session.setActiveToolsByName(filterActiveInterviewTools(chatActiveToolBaseline(this.sessionModeOf(sessionId))).allowed);
+        }
+        else
+            pinOperatorChatTools(session, this.sessionModeOf(sessionId));
+    }
+    /** Read-only rollout diagnostics; no model parameters or host identities. */
+    getToolExposure(sessionId) { return this.toolExposures.get(sessionId)?.snapshot; }
     /** Cached session-less custom tool definitions (operator + explore). */
     async loadCustomTools(sessionId) {
         const sessionMode = this.sessionModeOf(sessionId);
@@ -976,6 +1022,8 @@ export class ConsolePiRuntime {
                 : Promise.resolve([]),
             this.loadExploreCustomTools(),
         ]);
+        const scheduledGoalTools = loadWorkflowTools && this.options.actionContext
+            ? await buildScheduledGoalTools({ sessionId, actionContext: this.options.actionContext }) : [];
         const browserTools = await buildBrowserTools({
             automation: this.browserAutomation,
         });
@@ -1029,8 +1077,14 @@ export class ConsolePiRuntime {
             process.stderr.write(`[console] chat Agent tool build failed: ${error instanceof Error ? error.message : String(error)}\n`);
             return undefined;
         });
+        const exposure = this.toolExposures.get(sessionId);
+        const fullCapabilities = operatorCustomTools.find(tool => tool.name === "operatorCapabilities");
+        // Always session-bound: a branch can restore progressive after full fallback.
+        const discovery = exposure?.buildTool(fullCapabilities);
         return [
-            ...operatorCustomTools,
+            ...operatorCustomTools.filter(tool => !discovery || tool.name !== "operatorCapabilities"),
+            ...(discovery ? [discovery] : []),
+            ...scheduledGoalTools,
             ...exploreCustomTools,
             ...(questionTool ? [questionTool] : []),
             ...(todoTool ? [todoTool] : []),
@@ -1120,6 +1174,7 @@ export class ConsolePiRuntime {
         const entry = input.summary
             ? manager.branchWithSummary?.(input.branchFromEntryId, input.summary)
             : (manager.branch(input.branchFromEntryId), undefined);
+        this.pinSessionTools(input.sessionId, session);
         return {
             branchedFromEntryId: input.branchFromEntryId,
             ...(entry?.id ? { branchSummaryEntryId: entry.id } : {}),
@@ -1131,6 +1186,9 @@ export class ConsolePiRuntime {
             throw new Error(`chat session not active: ${sessionId}`);
         manager.branch(this.mainlineLeaves.get(sessionId));
         this.mainlineLeaves.delete(sessionId);
+        const session = this.sessions.get(sessionId);
+        if (session)
+            this.pinSessionTools(sessionId, session);
     }
     getBranchContext(sessionId) {
         const manager = this.sessionManagers.get(sessionId);
@@ -1390,7 +1448,7 @@ export class ConsolePiRuntime {
             if (services)
                 this.applySessionRecoveryOverrides(sessionId, services, session);
             await this.refreshModelConfiguration(sessionId, "force");
-            pinOperatorChatTools(session, this.sessionModeOf(sessionId));
+            this.pinSessionTools(sessionId, session);
         }
         catch (error) {
             return {
@@ -1532,7 +1590,14 @@ export class ConsolePiRuntime {
             extensions: inventories.extensions,
             packages: inventories.packages,
             mcp: inventories.mcp,
-            diagnostics: inventories.diagnostics,
+            diagnostics: [
+                ...inventories.diagnostics,
+                ...(this.toolExposures.has(sessionId) ? [{
+                        type: "info",
+                        code: "WORKFLOW_TOOL_EXPOSURE",
+                        message: JSON.stringify(this.toolExposures.get(sessionId).snapshot),
+                    }] : []),
+            ],
             hasBash: true,
         });
     }
@@ -1849,11 +1914,10 @@ export class ConsolePiRuntime {
             // explicitly restores the normal Operator Chat set (baseline + extension
             // tools, ADR 0012).
             const sessionMode = this.sessionModeOf(sessionId);
-            const requestedTools = chatActiveToolBaseline(sessionMode);
-            const activeTools = options?.mode === "requirement-interview" && sessionMode === "workflow"
-                ? filterActiveInterviewTools(requestedTools).allowed
-                : computeChatActiveToolNames(session, sessionMode);
-            session.setActiveToolsByName(activeTools);
+            this.pinSessionTools(sessionId, session, options?.mode === "requirement-interview" && sessionMode === "workflow");
+            if (sessionMode === "workflow" && isScheduledBookingTurn(text)) {
+                pinScheduledBookingTurnTools(session);
+            }
             // Final pre-prompt fence: abort after tool pin must still skip session.prompt.
             if (options?.signal?.aborted) {
                 return;
@@ -2186,6 +2250,7 @@ export class ConsolePiRuntime {
         }
         this.sessions.delete(sessionId);
         this.sessionManagers.delete(sessionId);
+        this.toolExposures.delete(sessionId);
         this.mainlineLeaves.delete(sessionId);
         this.modelRuntimes.delete(sessionId);
         this.modelConfigFiles.delete(sessionId);
@@ -2202,6 +2267,8 @@ export class ConsolePiRuntime {
         for (const id of [...this.sessions.keys()])
             this.dispose(id);
         void this.exploreOrchestrator.abortAll();
+        if (this.ownsBrowserAutomation)
+            void this.browserAutomation.dispose();
     }
 }
 function mapAssistantMessageEvent(type, sessionId, message) {

package/dist/worker/console/chat/routes.js

@@ -134,6 +134,16 @@ export function projectStoredMessagesWithEventOrder(messages, events) {
             if (event.kind !== expectedKind)
                 continue;
             const data = event.data;
+            // Exact alignment wins: since 2026-09-13 message_end frames carry the
+            // durable assistant message id, so restore matches by id, never by
+            // text (duplicate assistant texts would mis-align within a turn).
+            if (typeof data.messageId === "string" && data.messageId) {
+                if (data.messageId === message.id) {
+                    assistantCursor = index + 1;
+                    return event;
+                }
+                continue;
+            }
             const eventText = typeof data.text === "string"
                 ? data.text
                 : typeof data.message === "string"
@@ -271,6 +281,15 @@ function turnEventToStorePartial(event) {
                     text: String(event.text ?? ""),
                     ...(content ? { content } : {}),
                     ...(timing ? { timing } : {}),
+                    // Durable assistant message id (2026-09-13): the session
+                    // store persists message_end BEFORE framing, so a reconnecting
+                    // client and the restore projection can align on this id
+                    // instead of matching text within a time window.
+                    ...(typeof event.messageId ===
+                        "string" &&
+                        event.messageId
+                        ? { messageId: event.messageId }
+                        : {}),
                 },
             };
         }
@@ -4279,7 +4298,7 @@ async function dispatchChatRequest(req, res, deps, pathname, workspaceScope) {
             return true;
         }
     }
-    // Browser probe API (read-only; explains iframe refusals to the panel).
+    // Shared real-browser API for the Browser panel and chat browser tools.
     if (await handleBrowserRequest(req, res, {
         automation: deps.browserAutomation,
         requireWorkspace: () => workspaceScope