@tea-agent/loop-agent 0.42.0-next.14 → 0.42.0-next.16

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";
@@ -1950,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);
@@ -1958,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 &&
@@ -2007,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) {
@@ -2060,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",
@@ -2082,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,
@@ -2091,6 +2156,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 behavior: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("behavior") ?? [],
+                    executedTests,
                 },
             },
         });
@@ -2123,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
@@ -2603,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/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,
     });

package/dist/worker/console/chat/subagents/agent-tool.js

@@ -0,0 +1,62 @@
+/**
+ * Parent-session Agent custom tool. First slice: Explore only, one-shot.
+ */
+import { AGENT_TOOL_DESCRIPTION, AGENT_TOOL_PROMPT_GUIDELINES, AGENT_TOOL_PROMPT_SNIPPET, parseExploreAgentParams, } from "./explore-agent.js";
+import { OPERATOR_CHAT_AGENT_TOOL_NAME } from "./types.js";
+function textResult(payload, isError = false) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload) }],
+        details: payload,
+        ...(isError ? { isError: true } : {}),
+    };
+}
+export async function buildAgentCustomTool(options) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    return defineTool({
+        name: OPERATOR_CHAT_AGENT_TOOL_NAME,
+        label: "Explore",
+        description: AGENT_TOOL_DESCRIPTION,
+        promptSnippet: AGENT_TOOL_PROMPT_SNIPPET,
+        promptGuidelines: [...AGENT_TOOL_PROMPT_GUIDELINES],
+        executionMode: "parallel",
+        parameters: Type.Object({
+            description: Type.String({
+                description: "Short 3-5 word summary shown on the tool card",
+            }),
+            prompt: Type.String({
+                description: "Complete Explore brief. Include goal, known clues, exclusions, success criteria, and thoroughness (quick | medium | very thorough).",
+            }),
+            subagent_type: Type.Optional(Type.String({
+                description: "Built-in agent name. Omit or set Explore.",
+            })),
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params, signal) {
+            const parsed = parseExploreAgentParams(params);
+            if (!parsed.ok) {
+                const failure = {
+                    schemaVersion: 1,
+                    kind: "subagent",
+                    agent: "Explore",
+                    status: "failed",
+                    description: typeof params.description === "string" ? params.description : "",
+                    error: parsed.message,
+                    runId: "",
+                };
+                return textResult({
+                    ...failure,
+                    code: parsed.code,
+                }, true);
+            }
+            const result = await options.orchestrator.launch({
+                parentSessionId: options.parentSessionId,
+                request: parsed.request,
+                signal,
+                model: options.resolveModel?.(),
+            });
+            return textResult(result, result.status !== "completed");
+        },
+    });
+}