@tea-agent/loop-agent 0.28.8 → 0.28.9

package/dist/executors/pi-sdk-executor.js

@@ -457,6 +457,11 @@ export async function executeSingleSdkAttempt(options) {
             ...(requireWriterCustomTools ? { requireWriterCustomTools: true } : {}),
         });
         let resolveStall;
+        let resolveSettlement;
+        let settled = false;
+        const settlementPromise = new Promise((resolve) => {
+            resolveSettlement = resolve;
+        });
         const stallPromise = stallTimeoutMs > 0
             ? new Promise((resolve) => {
                 resolveStall = resolve;
@@ -470,6 +475,10 @@ export async function executeSingleSdkAttempt(options) {
             stallHandle = setTimeout(() => resolveStall?.("stall"), stallTimeoutMs);
         };
         unsubscribe = session.subscribe((event) => {
+            if (event.type === "agent_settled" && !settled) {
+                settled = true;
+                resolveSettlement?.("settled");
+            }
             // Every real SDK event proves transport activity, including noisy deltas
             // intentionally excluded from persisted JSONL and meaningful DAG progress.
             armStallWatchdog();
@@ -502,6 +511,9 @@ export async function executeSingleSdkAttempt(options) {
             ? `${filePrefix}\n${options.userMessage}`
             : options.userMessage;
         const promptPromise = session.prompt(promptMessage);
+        // A settlement event is permitted to win the race while prompt() remains
+        // pending. Observe a later rejection so it never becomes unhandled.
+        void promptPromise.catch(() => { });
         armStallWatchdog();
         const timeoutPromise = timeoutMs > 0
             ? new Promise((resolve) => {
@@ -512,10 +524,11 @@ export async function executeSingleSdkAttempt(options) {
             : null;
         const raced = await Promise.race([
             promptPromise.then(() => "done"),
+            settlementPromise,
             ...(timeoutPromise ? [timeoutPromise] : []),
             ...(stallPromise ? [stallPromise] : []),
         ]);
-        if (raced !== "done") {
+        if (raced !== "done" && raced !== "settled") {
             timedOut = true;
             appendStderr(raced === "stall"
                 ? `pi SDK step stalled after ${stallTimeoutMs}ms with no provider activity`

package/dist/executors/shell-executor.js

@@ -35,6 +35,7 @@ import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
 import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { parseAndValidateFinalWriteSetApproval, } from "../workflows/dag/node-execution.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 import { readRunState } from "../workflows/dag/run-store.js";
 import { resolveDagTaskSourcePath } from "../task/dag-source-paths.js";
@@ -42,26 +43,25 @@ import { readProjectGovernanceContext } from "../workflows/dag/project-governanc
 import { assertMavenPlanFresh, MavenPlanStaleError, } from "../verification/maven/index.js";
 /** In-memory same-run success cache. Never shared across runIds. */
 const sameRunShellCommandCaches = new Map();
-function shellCommandCacheKey(runId, nodeId) {
-    return `${runId}::${nodeId}`;
+function shellCommandCacheKey(runId, workspaceFingerprint, contractKey) {
+    return `${runId}::${workspaceFingerprint}::${contractKey}`;
 }
 function buildShellCommandContractKey(input) {
+    const environment = Object.fromEntries((input.envAllowlist ?? []).sort().map((name) => [name, process.env[name] ?? null]));
     return JSON.stringify({
-        commands: input.commands,
         cwd: input.cwd,
         timeoutMs: input.timeoutMs,
-        envAllowlist: input.envAllowlist ?? [],
+        environment,
         failFast: input.failFast,
         nonZeroExitPolicy: input.nonZeroExitPolicy ?? "fail",
+        controllerInput: input.controllerInput ?? null,
     });
 }
 export function clearSameRunShellCommandCachesForTests() {
     sameRunShellCommandCaches.clear();
 }
 function shouldReuseSuccessfulShellCommands(shell) {
-    // AC-005 targets supervised hard verify; also allow any shell node that
-    // carries final verifyEvidence so intermediate gates stay fail-closed fresh.
-    return shell.verifyEvidence?.phase === "final";
+    return shell.verifyEvidence?.phase === "intermediate" || shell.verifyEvidence?.phase === "final";
 }
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
 const SUMMARY_STDOUT_MAX = 4_000;
@@ -236,6 +236,15 @@ export function resolveShellCommands(shell) {
 export async function executeShellCommand(input) {
     return new Promise((resolve) => {
         const startedAt = Date.now();
+        const startedAtIso = new Date(startedAt).toISOString();
+        let lastOutputActivityAt = 0;
+        const reportOutputActivity = () => {
+            const now = Date.now();
+            if (now - lastOutputActivityAt < 500)
+                return;
+            lastOutputActivityAt = now;
+            input.reportActivity?.({ attempt: 1, kind: "output", at: new Date(now).toISOString() });
+        };
         const injectedEnv = input.dagRunMeta
             ? {
                 // Git Bash treats backslashes as escape characters inside double
@@ -271,6 +280,9 @@ export async function executeShellCommand(input) {
                 command: input.command,
                 cwd: input.cwd,
                 durationMs: Date.now() - startedAt,
+                wallDurationMs: Date.now() - startedAt,
+                startedAt: startedAtIso,
+                finishedAt: new Date().toISOString(),
                 stdout: formatBoundedOutput(stdout),
                 stdoutBytes: stdout.bytes,
                 stdoutTruncated: stdout.truncated,
@@ -293,10 +305,12 @@ export async function executeShellCommand(input) {
         child.stdout.on("data", (chunk) => {
             stdout = appendBoundedOutput(stdout, chunk);
             appendOutputArtifact(input.outputArtifacts?.stdoutPath, chunk);
+            reportOutputActivity();
         });
         child.stderr.on("data", (chunk) => {
             stderr = appendBoundedOutput(stderr, chunk);
             appendOutputArtifact(input.outputArtifacts?.stderrPath, chunk);
+            reportOutputActivity();
         });
         child.on("error", (error) => {
             stderr = appendBoundedOutput(stderr, `${stderr.text ? "\n" : ""}${error.message}`);
@@ -387,6 +401,17 @@ function summarizeCommandResults(results) {
         stderr: truncateOutput(stderr, NODE_STDERR_MAX).text,
     };
 }
+function parseCheckRepoSubcheckDurations(result) {
+    if (!/scripts\/check-repo\.sh/.test(result.command))
+        return [];
+    const durations = [];
+    for (const line of `${result.stdout}\n${result.stderr}`.split(/\r?\n/)) {
+        const match = /^CHECK_REPO_SUBCHECK_END name=(\S+) status=(success|failed) durationMs=(\d+)$/.exec(line.trim());
+        if (match)
+            durations.push({ name: match[1], status: match[2], durationMs: Number(match[3]) });
+    }
+    return durations;
+}
 export function buildShellResultSummaryMarkdown(input) {
     const lines = [
         "# Shell execution summary",
@@ -402,11 +427,11 @@ export function buildShellResultSummaryMarkdown(input) {
         "",
         "## Commands",
         "",
-        "| # | ok | exitCode | failureCategory | durationMs | cwd | command |",
-        "|---|----|----------|-----------------|------------|-----|---------|",
+        "| # | ok | exitCode | failureCategory | startedAt | finishedAt | wallDurationMs | executionDurationMs | reused | cwd | command |",
+        "|---|----|----------|-----------------|-----------|------------|----------------|---------------------|--------|-----|---------|",
     ];
     input.results.forEach((result, index) => {
-        lines.push(`| ${index + 1} | ${result.ok} | ${result.exitCode ?? "null"} | ${result.failureCategory} | ${result.durationMs} | ${result.cwd} | ${result.command.replace(/\|/g, "\\|")} |`);
+        lines.push(`| ${index + 1} | ${result.ok} | ${result.exitCode ?? "null"} | ${result.failureCategory} | ${result.startedAt ?? "(unknown)"} | ${result.finishedAt ?? "(unknown)"} | ${result.wallDurationMs ?? result.durationMs} | ${result.executionDurationMs ?? result.durationMs} | ${result.reused === true} | ${result.cwd} | ${result.command.replace(/\|/g, "\\|")} |`);
     });
     if (input.writeGuardViolations && input.writeGuardViolations.length > 0) {
         lines.push("", "## Write guard violations", "");
@@ -1299,6 +1324,7 @@ async function executePipelineCommands(input, meta, overrideCommands) {
             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`),
@@ -1332,6 +1358,7 @@ async function executeFrontendVerificationBundle(input, meta) {
             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`),
@@ -1382,6 +1409,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 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`),
@@ -1727,6 +1755,43 @@ async function executeFrontendLintBaseline(input, meta) {
 }
 export async function executeDagShellNode(input, meta) {
     const shell = input.task.shell;
+    if (shell?.finalWriteSetApprovalGate) {
+        const started = Date.now();
+        try {
+            const state = await readRunState(meta.runDir);
+            const writer = meta.spec.tasks.find((task) => task.id === shell.finalWriteSetApprovalGate.writerNodeId);
+            if (!writer)
+                throw new Error("final write-set approval gate writer is missing");
+            const authorization = parseAndValidateFinalWriteSetApproval({
+                task: writer,
+                spec: meta.spec,
+                state,
+            });
+            if (!authorization.ok)
+                throw new Error(authorization.reason);
+            return {
+                ok: true,
+                stdout: JSON.stringify({
+                    status: "approved",
+                    writerNodeId: writer.id,
+                    approvalDigest: authorization.approvalDigest,
+                    effectiveWriteSet: authorization.effectiveWriteSet,
+                }),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `final-write-set-approval-invalid: ${error instanceof Error ? error.message : String(error)}`,
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
     if (shell?.frontendBrowserToolPreflight) {
         const started = Date.now();
         try {
@@ -2160,6 +2225,9 @@ export async function executeDagShellNode(input, meta) {
                 command,
                 cwd: input.cwd,
                 durationMs: 0,
+                wallDurationMs: 0,
+                startedAt: new Date().toISOString(),
+                finishedAt: new Date().toISOString(),
                 exitCode: null,
                 failureCategory: "verification-plan-stale",
                 ok: false,
@@ -2198,6 +2266,7 @@ export async function executeDagShellNode(input, meta) {
     const timeoutMs = shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS;
     const failFast = shell.failFast !== false;
     const results = [];
+    const executedCommandKeys = new Set();
     let beforeStatus;
     let workspaceFingerprint;
     try {
@@ -2223,48 +2292,52 @@ export async function executeDagShellNode(input, meta) {
             workspaceFingerprint = undefined;
         }
         commandContractKey = buildShellCommandContractKey({
-            commands,
             cwd,
             timeoutMs,
             envAllowlist: shell.envAllowlist,
             failFast,
             nonZeroExitPolicy: shell.nonZeroExitPolicy,
+            controllerInput: {
+                sourceBinding: meta.spec.sourceBinding,
+                taskContractBinding: meta.spec.taskContractBinding,
+                runtimeContract: meta.spec.runtimeContract,
+            },
         });
-        const cacheKey = shellCommandCacheKey(meta.runId, input.task.id);
-        const existing = sameRunShellCommandCaches.get(cacheKey);
-        if (existing &&
-            existing.runId === meta.runId &&
-            existing.nodeId === input.task.id &&
-            existing.commandContractKey === commandContractKey &&
-            workspaceFingerprint &&
-            existing.workspaceFingerprint === workspaceFingerprint) {
+        const cacheKey = workspaceFingerprint
+            ? shellCommandCacheKey(meta.runId, workspaceFingerprint, commandContractKey)
+            : undefined;
+        const existing = cacheKey ? sameRunShellCommandCaches.get(cacheKey) : undefined;
+        if (existing && existing.runId === meta.runId && existing.contractKey === commandContractKey) {
             cache = existing;
         }
-        else {
-            sameRunShellCommandCaches.delete(cacheKey);
-            if (workspaceFingerprint) {
-                cache = {
-                    runId: meta.runId,
-                    nodeId: input.task.id,
-                    commandContractKey,
-                    workspaceFingerprint,
-                    byCommand: new Map(),
-                };
-                sameRunShellCommandCaches.set(cacheKey, cache);
-            }
+        else if (cacheKey && workspaceFingerprint) {
+            cache = {
+                runId: meta.runId,
+                contractKey: commandContractKey,
+                workspaceFingerprint,
+                byCommand: new Map(),
+            };
+            sameRunShellCommandCaches.set(cacheKey, cache);
         }
     }
     for (const command of commands) {
         const commandNumber = results.length + 1;
         // Cache each contractual occurrence independently. A result written for an
         // earlier duplicate in this round must not satisfy a later occurrence.
-        const commandCacheKey = `${commandNumber}:${command}`;
+        const commandCacheKey = command;
         const cached = cache?.byCommand.get(commandCacheKey);
-        if (cached) {
+        if (cached && !executedCommandKeys.has(commandCacheKey)) {
+            const reusedAt = new Date().toISOString();
             results.push({
                 command,
                 cwd: cached.cwd,
-                durationMs: cached.durationMs,
+                durationMs: 0,
+                wallDurationMs: 0,
+                executionDurationMs: cached.durationMs,
+                startedAt: reusedAt,
+                finishedAt: reusedAt,
+                sourceNodeId: cached.sourceNodeId,
+                sourceReceiptNodeId: cached.sourceReceiptNodeId,
                 exitCode: cached.exitCode,
                 failureCategory: cached.failureCategory,
                 ok: true,
@@ -2285,12 +2358,14 @@ export async function executeDagShellNode(input, meta) {
             timeoutMs,
             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`),
             },
         });
         results.push(result);
+        executedCommandKeys.add(commandCacheKey);
         if (result.ok && cache) {
             cache.byCommand.set(commandCacheKey, {
                 ok: true,
@@ -2304,6 +2379,10 @@ export async function executeDagShellNode(input, meta) {
                 stderrTruncated: result.stderrTruncated,
                 timedOut: result.timedOut,
                 durationMs: result.durationMs,
+                startedAt: result.startedAt ?? new Date().toISOString(),
+                finishedAt: result.finishedAt ?? new Date().toISOString(),
+                sourceNodeId: input.task.id,
+                sourceReceiptNodeId: input.task.id,
                 cwd: result.cwd,
             });
         }
@@ -2330,8 +2409,8 @@ export async function executeDagShellNode(input, meta) {
         }
     }
     // Write-guard or workspace mutation invalidates same-run success reuse.
-    if (!writeGuardOk && reuseEligible) {
-        sameRunShellCommandCaches.delete(shellCommandCacheKey(meta.runId, input.task.id));
+    if (!writeGuardOk && reuseEligible && workspaceFingerprint && commandContractKey) {
+        sameRunShellCommandCaches.delete(shellCommandCacheKey(meta.runId, workspaceFingerprint, commandContractKey));
     }
     const commandsOk = results.every((result) => result.ok);
     const recordNonZero = shell.nonZeroExitPolicy === "record";
@@ -2348,7 +2427,15 @@ export async function executeDagShellNode(input, meta) {
             ok: result.ok,
             exitCode: result.exitCode,
             failureCategory: result.failureCategory,
+            startedAt: result.startedAt,
+            finishedAt: result.finishedAt,
+            wallDurationMs: result.wallDurationMs,
+            executionDurationMs: result.executionDurationMs ?? result.durationMs,
             reused: result.reused === true,
+            reuseSource: result.reused
+                ? { nodeId: result.sourceNodeId, receiptNodeId: result.sourceReceiptNodeId }
+                : null,
+            subchecks: parseCheckRepoSubcheckDurations(result),
         })),
     };
     await writeDagNodeJsonArtifact(meta.runDir, input.task.id, "shell-command-receipt.json", receipt);

package/dist/governance/manifest-types.js

@@ -1,18 +1,11 @@
 import { z } from "zod";
+/** Compatibility type for Pi invocation internals; not a harness.json field. */
 export const stepModelConfigSchema = z.object({
     provider: z.string().optional(),
     model: z.string().optional(),
     thinking: z.string().optional(),
     timeoutMs: z.number().int().positive().optional(),
 });
-export const modelProfileSchema = stepModelConfigSchema.extend({
-    fallback: stepModelConfigSchema.optional(),
-});
-export const complexityRouteSchema = z.object({
-    small: z.string().optional(),
-    medium: z.string().optional(),
-    large: z.string().optional(),
-});
 export const worktreeManifestConfigSchema = z.object({
     rootRelativePath: z.string().optional().default(".worktrees"),
 });
@@ -21,10 +14,12 @@ export const CURSOR_TASK_EXECUTOR_REMOVED_ERROR = 'task executor "cursor" is no
 /** Per-tier model override: bare model id string, or `{ model, thinking? }`. */
 export const executorTierModelSchema = z.union([
     z.string(),
-    z.object({
+    z
+        .object({
         model: z.string().min(1),
         thinking: z.string().optional(),
-    }),
+    })
+        .strict(),
 ]);
 /** Normalize an executors.pi LOW|MED|HIGH value. */
 export function normalizeExecutorTierValue(value) {
@@ -46,20 +41,18 @@ export function normalizeExecutorTierValue(value) {
         ? { model, thinking }
         : { model };
 }
-export const executorManifestSchema = z.object({
+export const executorManifestSchema = z
+    .object({
     description: z.string().optional(),
     enabled: z.boolean().optional(),
+    /** Compatibility fallback for old projects; fresh init writes LOW/MED/HIGH instead. */
     defaultModel: z.string().optional().default("default"),
-    /**
-     * Per-complexity DAG model overrides. When set (and not the "default" sentinel),
-     * these take priority over defaultModel for the matching DAG executor tier.
-     * "default" literal and absent/undefined both mean "no override, fall through".
-     */
+    /** Per-complexity overrides take priority over defaultModel. */
     LOW: executorTierModelSchema.optional(),
     MED: executorTierModelSchema.optional(),
     HIGH: executorTierModelSchema.optional(),
-    requiresApiKey: z.string().optional(),
-});
+})
+    .strict();
 export const workflowPolicyProfileNameSchema = z.enum([
     "minimal",
     "standard",
@@ -192,6 +185,7 @@ export const workerPolicySchema = z.object({
 export const CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR = "harness executors.cursor is no longer supported; remove it and use executors.pi only (Cursor is available only via cursor-prompt sidecar)";
 export const harnessManifestSchema = z
     .object({
+    $schema: z.string().optional(),
     version: z.number(),
     project: z.string(),
     adapter: z.string().optional(),
@@ -207,48 +201,21 @@ export const harnessManifestSchema = z
     entrypoints: z.record(z.string(), z.string().nullable()),
     artifacts: z.record(z.string(), z.string().nullable()),
     scripts: z.record(z.string(), z.string().nullable()),
-    models: z
-        .object({
-        analyze: stepModelConfigSchema.optional(),
-        plan: stepModelConfigSchema.optional(),
-        implement: stepModelConfigSchema.optional(),
-        verify: stepModelConfigSchema.optional(),
-        retrospective: stepModelConfigSchema.optional(),
-    })
-        .optional()
-        .default({}),
-    modelProfiles: z
-        .record(z.string(), modelProfileSchema)
-        .optional()
-        .default({}),
-    modelRouting: z
-        .object({
-        analyze: complexityRouteSchema.optional(),
-        plan: complexityRouteSchema.optional(),
-        implement: complexityRouteSchema.optional(),
-        retrospective: complexityRouteSchema.optional(),
-        implementRetry: z.string().optional(),
-    })
-        .optional()
-        .default({}),
     workflowPolicy: workflowPolicySchema,
     /** Optional; absent means Night Scheduler uses package defaults when enabled by callers. */
     workerPolicy: workerPolicySchema.optional(),
     worktree: worktreeManifestConfigSchema.optional(),
     executors: z
-        .record(z.string(), executorManifestSchema)
+        .object({ pi: executorManifestSchema.optional() })
+        .strict()
         .optional()
         .default({}),
 })
+    .strict()
     .superRefine((manifest, ctx) => {
-    const executors = manifest.executors ?? {};
-    if ("cursor" in executors) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR,
-            path: ["executors", "cursor"],
-        });
-    }
+    // Preserve the empty read-only compatibility projection for callers that
+    // inspect parsed manifests, while rejecting this field in JSON input.
+    Object.assign(manifest, { modelProfiles: {} });
     const entrypoints = manifest.entrypoints ?? {};
     if ("cursorExecutorUsage" in entrypoints) {
         ctx.addIssue({

package/dist/task/source-prepare/build-draft.js

@@ -53,17 +53,18 @@ function resolveAcceptance(input) {
     return [];
 }
 function resolveAllowedPaths(input) {
+    const existingAllowed = input.baseDraft?.constraints.allowedPaths?.length
+        ? input.baseDraft.constraints.allowedPaths
+        : (input.existing?.allowedPaths ?? []);
+    const explicitAllowed = cleanStringList(input.flags.allowedPaths) ?? [];
+    // `--allowed-path` extends a managed boundary; it never replaces it.
     const source = input.flags.allowedPaths !== undefined
-        ? (cleanStringList(input.flags.allowedPaths) ?? [])
-        : input.baseDraft?.constraints.allowedPaths?.length
-            ? [...input.baseDraft.constraints.allowedPaths]
-            : input.existing?.allowedPaths?.length
-                ? [...input.existing.allowedPaths]
-                : [];
-    return source.map((raw) => {
+        ? [...existingAllowed, ...explicitAllowed]
+        : [...existingAllowed];
+    return dedupeStable(source.map((raw) => {
         const n = normalizePreparePath(raw);
         return n.ok ? n.value : raw.trim();
-    });
+    }));
 }
 function resolveAllowedRoots(input) {
     const roots = input.flags.allowedRoots ?? input.baseDraft?.constraints.allowedRoots ?? input.existing?.allowedRoots;
@@ -213,7 +214,7 @@ export function buildPrepareDraft(input) {
     if (baseDraft?.sourceResolutions?.length) {
         draft.sourceResolutions = [...baseDraft.sourceResolutions];
     }
-    if (baseDraft?.hardConstraints?.length && invariants.length === 0) {
+    if (baseDraft?.hardConstraints?.length) {
         draft.hardConstraints = [...baseDraft.hardConstraints];
     }
     return {

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

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { lstat } from "node:fs/promises";
+import { lstat, readFile } from "node:fs/promises";
 import { ContractMutationError, applyTaskContract, logicalRevisionForState, observeTaskContractState, projectConstraintsMarkdown, projectRequirementMarkdown, sha256OfCanonicalJson, validateDraftForTask, } from "../contract/index.js";
+import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
 import { getTaskContractPaths } from "../contract/paths.js";
 import { loadTaskConfig } from "../runtime.js";
 import { buildPrepareDraft } from "./build-draft.js";
@@ -26,6 +27,84 @@ async function loadExistingTaskConfig(repoRoot, taskId) {
         return null;
     }
 }
+async function loadManagedProjectionDraft(input) {
+    const config = input.existingTaskConfig;
+    if (!config) {
+        return { ok: false, message: "managed task config could not be loaded" };
+    }
+    try {
+        const [requirement, constraints] = await Promise.all([
+            readFile(input.requirementPath, "utf-8"),
+            readFile(input.constraintsPath, "utf-8"),
+        ]);
+        const requirementFacts = extractRequirementFactsFromMarkdown(requirement);
+        const constraintFacts = extractRequirementFactsFromMarkdown(constraints);
+        if (/^##\s+(?:References|Source Resolutions)\s*$/im.test(requirement)) {
+            return {
+                ok: false,
+                message: "managed requirement projection contains unsupported References or Source Resolutions; use loop-agent task advance " +
+                    input.taskId +
+                    " --from-draft <reviewed-draft.json> --json",
+            };
+        }
+        if (!requirementFacts.objective?.trim()) {
+            return {
+                ok: false,
+                message: "managed requirement projection is missing objective",
+            };
+        }
+        if (requirementFacts.acceptanceCriteria.length === 0) {
+            return {
+                ok: false,
+                message: "managed requirement projection is missing acceptance criteria",
+            };
+        }
+        if (!config.allowedPaths.length || !config.forbiddenPaths.length) {
+            return {
+                ok: false,
+                message: "managed task config is missing path boundaries",
+            };
+        }
+        return {
+            ok: true,
+            draft: {
+                schemaVersion: TASK_CONTRACT_DRAFT_SCHEMA_VERSION,
+                taskId: input.taskId,
+                title: config.title,
+                taskKind: config.taskKind,
+                ...(config.featureId ? { featureId: config.featureId } : {}),
+                requirement: {
+                    objective: requirementFacts.objective,
+                    scope: requirementFacts.scope,
+                    nonGoals: requirementFacts.nonGoals,
+                    acceptanceCriteria: requirementFacts.acceptanceCriteria,
+                },
+                constraints: {
+                    invariants: constraintFacts.invariants,
+                    allowedPaths: config.allowedPaths,
+                    forbiddenPaths: config.forbiddenPaths,
+                    ...(config.allowedRoots !== undefined
+                        ? { allowedRoots: config.allowedRoots }
+                        : {}),
+                },
+                verification: { commands: config.verifyCommands },
+                ...(requirementFacts.openQuestions.length > 0
+                    ? { openQuestions: requirementFacts.openQuestions }
+                    : {}),
+                ...(requirementFacts.assumptions.length > 0
+                    ? { assumptions: requirementFacts.assumptions }
+                    : {}),
+                hardConstraints: config.hardConstraints,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: `managed projection could not be reconstructed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
 function mutationOutcome(code) {
     switch (code) {
         case "REVISION_CONFLICT":
@@ -69,9 +148,8 @@ function buildNextSteps(input) {
         next.push(`loop-agent task advance ${input.taskId} --profile auto --json`);
         next.push("审查 DAG writeSet 后再 task advance --approve-gate ...");
     }
-    if (input.gaps.some((g) => g.code === "DIRTY_SOURCE")) {
-        next.push("loop-agent task status --json | task advance --from-draft ...");
-        next.push("或显式 --force-overwrite-source 后重跑 prepare");
+    if (input.gaps.some((g) => g.code === "DIRTY_SOURCE" || g.code === "MANAGED_PROJECTION_INCOMPLETE")) {
+        next.push(`loop-agent task advance ${input.taskId} --from-draft <reviewed-draft.json> --json`);
     }
     if (input.gaps.some((g) => g.code === "TRANSACTION_INCOMPLETE")) {
         next.push(`loop-agent task advance ${input.taskId} --json`);
@@ -132,6 +210,24 @@ export async function prepareTaskSource(input) {
         }
     }
     let baseDraft;
+    let managedProjectionError;
+    if ((input.intent.kind === "facts" &&
+        !input.intent.text &&
+        (state.effectiveStatus === "managed" ||
+            Boolean(state.ref && state.ref.revision > 0)))) {
+        const projection = await loadManagedProjectionDraft({
+            taskId,
+            existingTaskConfig,
+            requirementPath: contractPaths.requirementPath,
+            constraintsPath: contractPaths.constraintsPath,
+        });
+        if (projection.ok) {
+            baseDraft = projection.draft;
+        }
+        else {
+            managedProjectionError = projection.message;
+        }
+    }
     let facts;
     let sourceIntegrity = null;
     let hasImportedPrd = false;
@@ -272,6 +368,13 @@ export async function prepareTaskSource(input) {
         sourceFilesPresent,
         forceOverwriteSource: input.forceOverwriteSource,
     });
+    if (managedProjectionError) {
+        gaps.push({
+            code: "MANAGED_PROJECTION_INCOMPLETE",
+            level: "blocking",
+            message: managedProjectionError,
+        });
+    }
     // If --use-imported-prd and no parseable requirement and no AC from flags/text → blocking
     if (input.intent.kind === "facts" &&
         input.intent.useImportedPrd &&