@tea-agent/loop-agent 0.42.0-next.9 → 0.43.0-next.1

package/dist/executors/pi-extension-resolver.js

@@ -62,9 +62,21 @@ function readSettingsPackages(settingsPath) {
         return undefined;
     }
 }
-/** Strip an `npm:` prefix from a settings package spec, e.g. `npm:pi-lens`. */
+/**
+ * Strip an `npm:` prefix and a trailing `@<version>`/`@<dist-tag>` suffix
+ * from a settings package spec, e.g. `npm:pi-lens@3.8.72` → `pi-lens`,
+ * `npm:@scope/pkg@1.0.0` → `@scope/pkg`. The leading `@` of a scoped
+ * package name is preserved (the version separator is the LAST `@` at a
+ * positive index). Mirrors the console-side spec parsing semantics so a
+ * version-pinned install (e.g. via `pi install npm:pi-lens@3.8.72`) resolves
+ * identically in both surfaces.
+ */
 export function packageNameFromSpec(spec) {
-    return spec.startsWith("npm:") ? spec.slice(4) : spec;
+    const base = spec.startsWith("npm:") ? spec.slice(4) : spec;
+    const at = base.lastIndexOf("@");
+    if (at > 0)
+        return base.slice(0, at);
+    return base;
 }
 function loadPackageInventories(repoRoot) {
     const agentDir = getPiAgentDir();

package/dist/executors/shell-executor.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { withFrontendTestReporter, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -15,7 +16,7 @@ import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdi
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { extractBackendTestContractEnvelope } from "../workflows/dag/backend-test-contract-envelope.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
-import { assertFrontendSourceBindingFresh, buildContractFromCommittedFacts, deterministicSha256, frontendImplementationContractSchema, serializeCompactDeterministicJson, sha256Hex, writeFrontendImplementationContractArtifact, } from "../workflows/dag/frontend-implementation-contract.js";
+import { assertFrontendSourceBindingFresh, buildContractFromCommittedFacts, deterministicSha256, frontendImplementationContractSchema, serializeCompactDeterministicJson, sha256Hex, writeFrontendImplementationContractArtifact, buildFrontendVerifyCommandDirectory, } from "../workflows/dag/frontend-implementation-contract.js";
 import { checkFrontendSourceFidelityLedger } from "../workflows/dag/frontend-source-fidelity-ledger.js";
 import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
 import { copyFrontendTestStandardScenarios } from "../workflows/dag/frontend-test-standard-scenarios.js";
@@ -1907,11 +1908,12 @@ async function executePipelineCommands(input, meta, overrideCommands) {
     return results;
 }
 /** A+B (AC-008): derive unresolved verification entrypoints from committed plan
- * facts. A verification target is unresolved when its commandLabel does not
- * match any frozen command label from the verify shell evidence bundle.
- * Returns `{ ref, digest }` entries; a missing/unreadable plan ledger fails
- * closed to [] so the router restarts the contract instead of inventing refs. */
-async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandLabels) {
+ * facts. A verification target is unresolved when its commandId does not
+ * match any frozen command directory entry derived from the verify shell
+ * evidence bundle. Returns `{ ref, digest }` entries; a missing/unreadable
+ * plan ledger fails closed to [] so the router restarts the contract instead
+ * of inventing refs. */
+async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandIds) {
     try {
         const { restorePlanPatchFromCommittedFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, "frontend-plan-pi", "plan-typed-facts.jsonl"));
@@ -1920,15 +1922,13 @@ async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandL
             ?.verificationTargets;
         if (!Array.isArray(targets))
             return [];
-        const frozen = new Set(frozenCommandLabels
-            .map((label) => label.trim().toLowerCase())
-            .filter(Boolean));
+        const frozen = new Set(frozenCommandIds.filter(Boolean));
         const refs = [];
         for (const item of targets) {
             const target = item;
-            const commandLabel = typeof target.commandLabel === "string" ? target.commandLabel : "";
-            if (commandLabel &&
-                frozen.has(commandLabel.trim().toLowerCase())) {
+            // v2 plan facts carry commandId as the stable directory key.
+            const commandId = typeof target.commandId === "string" ? target.commandId : "";
+            if (commandId && frozen.has(commandId)) {
                 continue;
             }
             const file = typeof target.file === "string" ? target.file : "";
@@ -1951,6 +1951,23 @@ async function executeFrontendVerificationBundle(input, meta) {
     const bundle = shell.frontendVerificationBundle;
     const cwd = resolveShellCwd(input.cwd, shell.cwd);
     const results = [];
+    const commandResultsByKey = new Map();
+    const commandKey = (command) => `${cwd}\u0000${command.trim()}`;
+    const reuseCommandResult = (result, command) => {
+        const reusedAt = new Date().toISOString();
+        return {
+            ...result,
+            command,
+            durationMs: 0,
+            wallDurationMs: 0,
+            executionDurationMs: result.executionDurationMs ?? result.durationMs,
+            startedAt: reusedAt,
+            finishedAt: reusedAt,
+            stdoutArtifactPath: undefined,
+            stderrArtifactPath: undefined,
+            reused: true,
+        };
+    };
     let beforeStatus;
     try {
         beforeStatus = await readGitStatusPorcelain(input.cwd);
@@ -1959,22 +1976,32 @@ async function executeFrontendVerificationBundle(input, meta) {
         beforeStatus = undefined;
     }
     const lintResults = [];
+    const successfulLabels = new Map();
+    const successfulCommandTexts = new Map();
+    const executedTests = new Map();
+    const commandExecutionEvidence = new Map();
     for (const command of bundle.lintCommands ?? []) {
-        const commandNumber = results.length + 1;
-        const result = await executeShellCommand({
-            command,
-            cwd,
-            timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
-            envAllowlist: shell.envAllowlist,
-            dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
-            reportActivity: input.reportActivity,
-            outputArtifacts: {
-                stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
-                stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
-            },
-        });
-        lintResults.push(result);
+        const key = commandKey(command);
+        const cached = commandResultsByKey.get(key);
+        let result = cached ? reuseCommandResult(cached, command) : undefined;
+        if (!result) {
+            const commandNumber = results.length + 1;
+            result = await executeShellCommand({
+                command,
+                cwd,
+                timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+                envAllowlist: shell.envAllowlist,
+                dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+                reportActivity: input.reportActivity,
+                outputArtifacts: {
+                    stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                    stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+                },
+            });
+            commandResultsByKey.set(key, result);
+        }
         results.push(result);
+        lintResults.push(result);
     }
     let lintAssessment;
     if ((bundle.lintCommands?.length ?? 0) > 0 &&
@@ -2008,30 +2035,64 @@ async function executeFrontendVerificationBundle(input, meta) {
             labels: bundle.behaviorEvidence.commandLabels,
         },
     ];
-    const successfulLabels = new Map();
+    const failedGroups = new Set();
+    const groupFailures = [];
     for (const group of lintBlocked ? [] : groups) {
         for (const [index, command] of group.commands.entries()) {
-            const commandNumber = results.length + 1;
-            const result = await executeShellCommand({
-                command,
-                cwd,
-                timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
-                envAllowlist: shell.envAllowlist,
-                dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
-                reportActivity: input.reportActivity,
-                outputArtifacts: {
-                    stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
-                    stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
-                },
-            });
+            if (failedGroups.has(group.name))
+                break;
+            const key = commandKey(command);
+            const cached = commandResultsByKey.get(key);
+            let result = cached ? reuseCommandResult(cached, command) : undefined;
+            if (!result) {
+                const commandNumber = results.length + 1;
+                const reportPath = path.join(meta.runDir, input.task.id, "commands", `${commandNumber}-${randomUUID()}.vitest.json`);
+                const observedCommand = await withFrontendTestReporter({ command, cwd, reportPath });
+                if (observedCommand)
+                    await mkdir(path.dirname(reportPath), { recursive: true });
+                result = await executeShellCommand({
+                    command: observedCommand ?? command,
+                    cwd,
+                    timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+                    envAllowlist: shell.envAllowlist,
+                    dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+                    reportActivity: input.reportActivity,
+                    outputArtifacts: {
+                        stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                        stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+                    },
+                });
+                let reportError;
+                if (observedCommand && result.ok) {
+                    try {
+                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(await readFile(reportPath, "utf8")), cwd));
+                    }
+                    catch (error) {
+                        reportError = `frontend test execution report unavailable: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                }
+                if (reportError) {
+                    result = { ...result, ok: false, failureCategory: "invalid-output", stderr: reportError };
+                }
+                commandResultsByKey.set(key, result);
+            }
             results.push(result);
             if (result.ok && group.labels[index]) {
+                const observations = commandExecutionEvidence.get(key);
+                if (observations !== undefined)
+                    executedTests.set(group.labels[index], observations);
                 const labels = successfulLabels.get(group.name) ?? [];
                 labels.push(group.labels[index]);
                 successfulLabels.set(group.name, labels);
+                const texts = successfulCommandTexts.get(group.name) ?? [];
+                texts.push(command);
+                successfulCommandTexts.set(group.name, texts);
             }
-            if (!result.ok)
+            if (!result.ok) {
+                groupFailures.push(result);
+                failedGroups.add(group.name);
                 break;
+            }
         }
     }
     if (beforeStatus !== undefined) {
@@ -2061,12 +2122,15 @@ async function executeFrontendVerificationBundle(input, meta) {
         exitCode: result.exitCode,
         failureCategory: result.failureCategory,
         command: result.command,
+        reused: result.reused === true,
     }));
+    // Lint baseline-debt is tolerated, so a lint-only failure must not become the
+    // verification failure. A shared lint/static or lint/behavior command is
+    // different: once reused by a non-lint lane, its failure belongs to that lane
+    // and must remain the primary failure evidence.
     const firstFailure = lintBlocked
         ? lintResults.find((result) => !result.ok)
-        : results
-            .filter((result) => !lintResults.includes(result))
-            .find((result) => !result.ok);
+        : groupFailures[0];
     const lintSyntheticFailure = lintBlocked && !firstFailure
         ? {
             failureCategory: "invalid-output",
@@ -2083,7 +2147,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 mock: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("mock") ?? [],
-                    commandTexts: bundle.mockCommands.slice(0, successfulLabels.get("mock")?.length ?? 0),
+                    commandTexts: successfulCommandTexts.get("mock") ?? [],
                 },
                 static: {
                     nodeId: input.task.id,
@@ -2092,6 +2156,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 behavior: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("behavior") ?? [],
+                    executedTests,
                 },
             },
         });
@@ -2124,7 +2189,9 @@ async function executeFrontendVerificationBundle(input, meta) {
             nodeId: failedNodeId,
             rawFailureCategory: failureCategory,
         });
-        const failureOwner = classifiedOwner === "unknown" ? "implement-pi" : classifiedOwner;
+        const failureOwner = classifiedOwner === "unknown" &&
+            ["typecheck", "build", "lint", "component-test", "unit-test", "trace"].includes(failureClass)
+            ? "implementation" : classifiedOwner;
         const restartPhase = classifyRestartPhase(failureOwner);
         // A+B (AC-008): verification-config routing. Produce structured
         // unresolved entrypoint refs from committed plan facts and the frozen
@@ -2135,12 +2202,18 @@ async function executeFrontendVerificationBundle(input, meta) {
         // never re-classifies the same signal twice.
         let verificationConfigRoute;
         if (failureOwner === "verification-config") {
-            const frozenCommandLabels = [
-                ...(bundle.staticEvidence.commandLabels ?? []),
-                ...(bundle.behaviorEvidence.commandLabels ?? []),
-                ...(bundle.mockEvidence?.commandLabels ?? []),
-            ];
-            const unresolvedEntrypointRefs = await deriveUnresolvedVerificationEntrypointRefs(meta.runDir, frozenCommandLabels);
+            const verifyDirectory = buildFrontendVerifyCommandDirectory({
+                staticLabels: bundle.staticEvidence.commandLabels ?? [],
+                behaviorLabels: bundle.behaviorEvidence.commandLabels ?? [],
+                mockLabels: bundle.mockEvidence?.commandLabels ?? [],
+                lintLabels: bundle.lintEvidence?.commandLabels ?? [],
+                staticCommandTexts: bundle.staticEvidence.commandTexts ?? [],
+                behaviorCommandTexts: bundle.behaviorEvidence.commandTexts ?? [],
+                mockCommandTexts: bundle.mockEvidence?.commandTexts ?? [],
+                lintCommandTexts: bundle.lintEvidence?.commandTexts ?? [],
+            });
+            const frozenCommandLabels = verifyDirectory.map((entry) => entry.label);
+            const unresolvedEntrypointRefs = await deriveUnresolvedVerificationEntrypointRefs(meta.runDir, verifyDirectory.map((entry) => entry.commandId));
             verificationConfigRoute = routeVerificationConfig({
                 unresolvedEntrypointRefs: unresolvedEntrypointRefs.map((ref) => ref.ref),
             });
@@ -2531,7 +2604,7 @@ async function executeFrontendDesignPolicy(input, meta) {
                 };
             }
             const uncoveredVTs = contract.verificationTargets
-                .filter((vt) => vt.type !== "static")
+                .filter((vt) => vt.mode !== "static")
                 .filter((vt) => ![...writeSet].some((pattern) => pathMatchesPattern(vt.file, pattern) || vt.file === pattern));
             if (uncoveredVTs.length > 0) {
                 return {
@@ -2598,6 +2671,10 @@ async function executeFrontendDesignPolicy(input, meta) {
                 [],
             allowedDependencies: config.allowedDependencies,
             writeSetPatterns: config.implementationWriteSet ?? [],
+            // Fresh-existence evidence at gate time (Scout pathEvidence.fresh
+            // semantics): a reuse-existing evidencePath must name a file that
+            // exists NOW; greenfield paths are decision=new only.
+            hasFreshPathEvidence: (candidate) => existsSync(path.resolve(input.cwd, candidate)),
         });
         // 8. Write canonical contract + policy result.
         const contractArtifact = await writeFrontendImplementationContractArtifact({

package/dist/shared/dag-failure-category.js

@@ -63,6 +63,12 @@ const RAW_TO_NORMALIZED = {
     // compaction / fresh context before retrying — an executor-side
     // environment condition, not a plan-quality defect.
     "context-overflow": "executor",
+    // stopReason=length output-capacity truncation: same executor-side
+    // capacity class as context-overflow. Legacy thinking-exhausted labels
+    // (pre-output-limit artifacts) map to the same class.
+    "output-limit": "executor",
+    "writer-thinking-exhausted": "executor",
+    "planner-thinking-exhausted": "executor",
     // Deterministic capability/policy refusal: missing verified launcher JS
     // entry, capability allowlist rejection, or missing bounded write tool
     // profile. These are environment/config defects the operator repairs

package/dist/task/contract/apply.js

@@ -147,7 +147,7 @@ export async function applyTaskContract(input) {
             ref,
             changedFiles: [],
             idempotentReplay: true,
-            txId: existing.txId,
+            ...(existing.txId ? { txId: existing.txId } : { noOp: true }),
         };
     }
     const lock = await acquireTaskContractLock({
@@ -175,7 +175,9 @@ export async function applyTaskContract(input) {
                 ref,
                 changedFiles: [],
                 idempotentReplay: true,
-                txId: existingUnderLock.txId,
+                ...(existingUnderLock.txId
+                    ? { txId: existingUnderLock.txId }
+                    : { noOp: true }),
             };
         }
         const state = await observeTaskContractState(input.repoRoot, input.taskId);
@@ -251,6 +253,38 @@ export async function applyTaskContract(input) {
             sourceHashes,
             taskConfigSha256,
         });
+        // Content-level no-op: when the freshly projected draft hashes
+        // identically to both the recorded contract and the on-disk observation,
+        // the journaled commit would only churn revision/updatedAt metadata and
+        // force downstream consumers (writeSet gate digest binds
+        // contractRevision+contractCanonicalHash) to re-issue approvals for
+        // zero content change. Return the current ref untouched instead. A
+        // drifted disk (observed !== ref) never reaches this short-circuit: the
+        // apply is then a repair projection and must run.
+        if (state.ref &&
+            canonicalHash === state.ref.canonicalHash &&
+            state.observedCanonicalHash === state.ref.canonicalHash) {
+            await assertLockHeld(lock);
+            await appendRequestLedgerEntry({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                entry: {
+                    schemaVersion: 1,
+                    requestId: input.requestId,
+                    requestPayloadSha256: input.requestPayloadSha256,
+                    revision: state.ref.revision,
+                    canonicalHash: state.ref.canonicalHash,
+                    recordedAt: new Date().toISOString(),
+                    resultSummary: { ok: true, operation: "apply" },
+                },
+            });
+            return {
+                ref: state.ref,
+                changedFiles: [],
+                idempotentReplay: false,
+                noOp: true,
+            };
+        }
         const nextRevision = currentRevision + 1;
         const nextRef = {
             schemaVersion: TASK_CONTRACT_REF_SCHEMA_VERSION,

package/dist/task/source-prepare/parse-intent.js

@@ -13,6 +13,13 @@ const HEADING_ALIASES = {
         "需求范围",
         "已确认范围",
         "已确认需求",
+        // Common zh-CN frontend-PRD variants seen in real PRDs; without these a
+        // raw-PRD fallback parse (semantic intake unavailable) yields an empty
+        // scope and flips the import to incomplete (EMPTY scope deadlock).
+        "目标表面",
+        "交付范围",
+        "实现范围",
+        "交付内容",
     ]),
     nonGoals: new Set(["非目标", "out of scope", "non-goals", "non goals"]),
     acceptance: new Set([

package/dist/worker/console/chat/chat-event-store.js

@@ -22,14 +22,16 @@ import path from "node:path";
 import { ensureSecureDir, writeSecureJsonSync, } from "../../../infrastructure/console/app-data.js";
 import { isTerminalOperationState, } from "../../../infrastructure/console/operation-store.js";
 import { scrubSecrets } from "./explore-tools.js";
-const OPERATION_PREVIEW_MAX_CHARS = 1200;
+/** Bounded preview stored on the event ring / SSE (not the live tool payload). */
+export const OPERATION_PREVIEW_MAX_CHARS = 4000;
+const OPERATION_PREVIEW_TRUNCATION_SUFFIX = "…[truncated]";
 function boundedRedactedText(value, maxChars = OPERATION_PREVIEW_MAX_CHARS) {
     if (typeof value !== "string" || !value.trim())
         return undefined;
     const { scrubbed } = scrubSecrets(value);
     return scrubbed.length <= maxChars
         ? scrubbed
-        : `${scrubbed.slice(0, maxChars)}…[truncated]`;
+        : `${scrubbed.slice(0, maxChars)}${OPERATION_PREVIEW_TRUNCATION_SUFFIX}`;
 }
 function safeIdentity(value) {
     return boundedRedactedText(value, 240);

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

@@ -32,7 +32,8 @@ import { extractAssistantContentBlocks, extractAssistantText, isAssistantSdkMess
 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 { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.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";
@@ -115,6 +116,7 @@ export function OPERATOR_CHAT_ACTIVE_TOOL_NAMES() {
         ...OPERATOR_CHAT_ALLOWED_TOOLS,
         ...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS,
         ...OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS,
+        ...OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS,
     ];
 }
 /**
@@ -1024,14 +1026,33 @@ export class ConsolePiRuntime {
     compactionControllers = new Map();
     siftStates = new Map();
     /** Session-less tool definition caches (no AgentSession state). */
-    /** Session-less tool definition caches (no AgentSession state). */
     operatorCustomToolsPromise;
     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,
+                });
+            },
+        });
     }
     /** Absolute path for repo-scoped resource preferences (may be undefined in unit tests). */
     get resourcePreferencesPath() {
@@ -1526,12 +1547,31 @@ export class ConsolePiRuntime {
         const goalTools = this.options.goalRegistry
             ? await buildGoalTools({ sessionId, registry: this.options.goalRegistry })
             : [];
+        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,
+            ...(agentTool ? [agentTool] : []),
         ];
     }
     loadOperatorCustomTools() {
@@ -2595,6 +2635,7 @@ export class ConsolePiRuntime {
             catch {
                 // ignore
             }
+            void this.exploreOrchestrator.abortByParent(sessionId);
         };
         try {
             if (options?.turnId && this.options.questionRegistry) {
@@ -2970,10 +3011,12 @@ export class ConsolePiRuntime {
         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) {

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);

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

@@ -517,6 +517,14 @@ export async function handleChatCapabilities(_req, res, deps) {
         deniedTools: OPERATOR_CHAT_DENIED_TOOLS,
         deniedOperatorActions: OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS,
         tools: toolSchemas,
+        builtinSubagents: [
+            {
+                toolId: "Agent",
+                agent: "Explore",
+                kind: "subagent",
+                description: "Start the built-in read-only Explore subagent for codebase search, symbol lookup, and call-chain tracing.",
+            },
+        ],
         // ADR 0011: full Pi tools including bash are default-active.
         hasBash: true,
     });
@@ -851,6 +859,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         }
     }
     await deps.operationLinker.recoverSession(sessionId);
+    const messagePage = await deps.store.listMessages(sessionId, { limit: 50 });
     const composerDraft = await new ComposerDraftStore(deps.appData).get(sessionId);
     const snapshot = deps.events.snapshot(sessionId);
     const telemetry = deriveChatSessionTelemetry(snapshot);
@@ -862,7 +871,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         eventEpoch: deps.events.epoch(sessionId),
         session: {
             ...projectBrowserChatSession(record),
-            messages: projectStoredMessagesWithEventOrder(record.messages, snapshot),
+            messages: projectStoredMessagesWithEventOrder(messagePage.messages, snapshot),
             composerDraft,
             activeTurnId: activeTurn?.turnId,
             turnPhase: activeTurn
@@ -874,6 +883,10 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
             todos: projectCurrentTodos(snapshot) ?? [],
             goal: deps.goalRegistry?.get(sessionId) ?? null,
         },
+        history: {
+            hasMore: messagePage.hasMore,
+            ...(messagePage.nextCursor ? { nextCursor: messagePage.nextCursor } : {}),
+        },
         hasBash: true,
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
@@ -1134,19 +1147,18 @@ export async function handleSteerDeferredTurn(req, res, deps, sessionId, clientR
     }
 }
 async function persistAcceptedSteering(deps, sessionId, turnId, userMessage, clientRequestId) {
+    emitUserMessageEvent(deps, sessionId, turnId, userMessage, clientRequestId, true);
+    await emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, 0);
+}
+function emitUserMessageEvent(deps, sessionId, turnId, userMessage, clientRequestId, steering = false) {
     deps.events.append(sessionId, turnId, {
         kind: "user_message",
         data: {
-            clientRequestId,
-            steering: true,
-            message: {
-                id: userMessage.id,
-                text: userMessage.text,
-                at: userMessage.at,
-            },
+            ...(clientRequestId ? { clientRequestId } : {}),
+            ...(steering ? { steering: true } : {}),
+            message: { id: userMessage.id, text: userMessage.text, at: userMessage.at },
         },
     });
-    await emitDeferredTurnUpdate(deps, sessionId, turnId, undefined, 0);
 }
 /** Lightweight busy-truth endpoint for the client reconcile loop (pi-web
  *  get_state equivalent): exposes the active turn + the latest turn's durable
@@ -1690,7 +1702,8 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
             text,
             images,
             signal: ac.signal,
-            onUserMessagePersisted: (record) => {
+            onUserMessagePersisted: (record, userMessage) => {
+                emitUserMessageEvent(deps, sessionId, turnId, userMessage);
                 const users = record.messages.filter((message) => message.role === "user");
                 if (users.length !== 1)
                     return;
@@ -2000,9 +2013,12 @@ export async function handleCreateChatTurn(req, res, deps, sessionId, trustedPay
                 sessionId,
                 turnId: turn.turnId,
                 text,
+                clientRequestId,
                 images,
                 signal: controller.signal,
                 onUserMessagePersisted: async (record, userMessage) => {
+                    if (!trustedPayload)
+                        emitUserMessageEvent(deps, sessionId, turn.turnId, userMessage, clientRequestId);
                     await trustedPayload?.onUserMessagePersisted?.(turn.turnId, userMessage);
                     const users = record.messages.filter((message) => message.role === "user");
                     if (users.length !== 1)
@@ -2845,8 +2861,8 @@ async function handleSddBingo(req, res, deps, sessionId) {
         if (Object.keys(body).some((key) => key !== "skillName")) {
             throw new SddDataAlignmentError("SDD_INVALID_SKILL_NAME", "请求体只允许 skillName 字段", 400);
         }
-        await deps.sddDataAlignment.report(sessionId, body.skillName);
-        sendJson(res, 200, { ok: true });
+        const result = await deps.sddDataAlignment.report(sessionId, body.skillName);
+        sendJson(res, 200, { ok: true, skillName: result.skillName });
     }
     catch (error) {
         if (error instanceof SddDataAlignmentError) {