@tea-agent/loop-agent 0.42.0-next.8 → 0.42.0

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),
             });
@@ -2299,19 +2372,38 @@ async function collectReviewRestartPhase(runDir, reviewNodeId) {
 }
 /** A+B (AC-009): deterministic §4.10 restart phase for a committed
  * `request_design_changes` fact. Mirrors the review collector. */
-/** Number of findings attached to the committed request_design_changes
- * terminal fact (0 when absent) — used for the admission advisory. */
-async function collectDesignReviewFindingCount(runDir, designNodeId) {
+/** Read the committed design request as a bounded structured capsule. */
+async function collectDesignReviewFindings(runDir, designNodeId) {
     try {
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, designNodeId, "design-typed-facts.jsonl"));
         const request = records.find((record) => record.phase === "committed" &&
             record.fact.kind ===
                 "request_design_changes");
-        const findings = (request?.fact).findings;
-        return Array.isArray(findings) ? findings.length : 0;
+        const fact = request?.fact;
+        const findings = Array.isArray(fact?.findings)
+            ? fact.findings.flatMap((finding) => {
+                if (!finding || typeof finding !== "object")
+                    return [];
+                const value = finding;
+                if (!(["Critical", "Important", "Minor", "Info"].includes(value.severity) &&
+                    typeof value.issue === "string" && value.issue.trim().length > 0))
+                    return [];
+                return [{
+                        severity: value.severity,
+                        ...(typeof value.file === "string" && value.file.trim() ? { file: value.file } : {}),
+                        ...(typeof value.line === "number" && Number.isInteger(value.line) && value.line > 0 ? { line: value.line } : {}),
+                        issue: value.issue,
+                        ...(typeof value.requiredChange === "string" && value.requiredChange.trim() ? { requiredChange: value.requiredChange } : {}),
+                    }];
+            }).slice(0, 16)
+            : [];
+        const evidenceRefs = Array.isArray(fact?.evidenceRefs)
+            ? fact.evidenceRefs.filter((ref) => typeof ref === "string" && ref.trim().length > 0).slice(0, 16)
+            : [];
+        return { findings, evidenceRefs };
     }
     catch {
-        return 0;
+        return { findings: [], evidenceRefs: [] };
     }
 }
 async function collectDesignRestartPhase(runDir, designNodeId) {
@@ -2512,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 {
@@ -2579,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({
@@ -2625,17 +2721,15 @@ async function executeFrontendWriterAdmission(input, meta) {
     const shell = input.task.shell;
     const config = shell.frontendWriterAdmission;
     try {
-        // 1. Design verdict handling (r12 policy change). The typed terminal
+        // 1. Design verdict handling. The typed terminal
         // verdict is read from the committed typed design terminal fact, not
         // from the legacy first-line VERDICT text protocol (AC-003/AC-004).
-        // A request_design_changes verdict no longer blocks writer admission:
-        // it is downgraded to an advisory that rides along in the admission
-        // receipt (and reaches implement via the review node's upstream
-        // context). Blocking is owned by the deterministic gates (prewrite,
-        // write guard) and the final code review. A missing typed terminal
-        // verdict still fails closed. In small topology the design review node
-        // is absent and the check is vacuous.
+        // A request_design_changes verdict blocks writer admission and is copied
+        // into the receipt as a bounded advisory capsule for recovery. A missing
+        // typed terminal verdict still fails closed. In small topology the design
+        // review node is absent and the check is vacuous.
         let verdictPass = true;
+        let designRequested = false;
         let designAdvisory;
         if (config.designReviewFromNodeId) {
             const designKinds = await collectDesignTerminalKinds(meta.runDir, config.designReviewFromNodeId);
@@ -2643,11 +2737,16 @@ async function executeFrontendWriterAdmission(input, meta) {
                 verdictPass = false;
             }
             else if (designKinds[0] !== "approve_design") {
+                designRequested = true;
+                const designFindings = await collectDesignReviewFindings(meta.runDir, config.designReviewFromNodeId);
                 designAdvisory = {
-                    verdict: designKinds[0],
+                    verdict: "request_design_changes",
                     restartPhase: await collectDesignRestartPhase(meta.runDir, config.designReviewFromNodeId),
-                    findingCount: await collectDesignReviewFindingCount(meta.runDir, config.designReviewFromNodeId),
+                    findingCount: designFindings.findings.length,
+                    findings: designFindings.findings,
+                    evidenceRefs: designFindings.evidenceRefs,
                 };
+                verdictPass = false;
             }
         }
         // 2. Read the canonical contract + design-policy result.
@@ -2715,7 +2814,9 @@ async function executeFrontendWriterAdmission(input, meta) {
             allowedMockStrategies: config.allowedMockStrategies,
             workspaceFiles,
         });
-        // 6. Design verdict enforcement: request-revision is a blocked admission.
+        // 6. Design verdict enforcement: request_design_changes is a blocked
+        // admission. This keeps the writer fail-closed until the recovery plan
+        // has incorporated the reviewer's concrete findings.
         const failureSource = policyRaw.classification === "blocked"
             ? "frontend-design-policy-shell"
             : "frontend-writer-admission-shell";
@@ -2724,8 +2825,12 @@ async function executeFrontendWriterAdmission(input, meta) {
             : [
                 ...admission.findings,
                 {
-                    code: "design-approval-missing",
-                    message: "design review typed terminal verdict missing or ambiguous (fail closed)",
+                    code: designRequested
+                        ? "design-review-requested"
+                        : "design-approval-missing",
+                    message: designRequested
+                        ? "design review requested changes; writer admission is blocked until recovery incorporates the committed findings"
+                        : "design review typed terminal verdict missing or ambiguous (fail closed)",
                 },
             ];
         const classification = findings.length === 0 && admission.classification === "accepted"

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