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

package/dist/executors/pi-executor.js

@@ -707,8 +707,6 @@ function shouldFallbackSdkToCli(sdkResult, validationIssues, options) {
         return true;
     if (!sdkResult.ok &&
         (sdkResult.failureCategory === "auth" ||
-            sdkResult.failureCategory === "output-limit" ||
-            sdkResult.failureCategory === "cancelled" ||
             sdkResult.failureCategory === "timeout" ||
             sdkResult.failureCategory === "termination-unconfirmed")) {
         return false;

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

@@ -9,9 +9,6 @@ import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DE
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
 import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
-/** Maximum number of same-session continuations after provider output truncation. */
-export const PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX = 3;
-export const PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT = "继续。上一轮因输出长度上限（stopReason=length）截断；当前会话、工具与已完成工作仍保留。只完成尚未完成的部分，不重做已成功的写入或事实提交。";
 /** Wrap the actual stream seam: tool turns, retries and compaction all await it. */
 export async function installPiProviderRequestBudget(session, reserve, onFailure, capacity) {
     const agent = session.agent;
@@ -614,8 +611,6 @@ async function executeSingleSdkAttemptInternal(options) {
     const requestEnvelopeObservation = { peakBytes: 0, peakEstimatedTokens: 0, estimatorVersion: "utf8-bytes-div3-v1-estimate" };
     const stdoutPreview = new BoundedTextPreview("stdout");
     const stdoutCollector = createPiJsonlStreamCollector();
-    let turnCollector = createPiJsonlStreamCollector();
-    let committedTerminalObserved = false;
     const usageSamples = [];
     const observationEvents = [];
     const readObservation = createFrontendReadObservation();
@@ -627,9 +622,6 @@ async function executeSingleSdkAttemptInternal(options) {
     // length-stopped thinking-only attempt with no persisted write tool calls is
     // still distinguishable from generic empty output.
     let stopReason;
-    let providerErrorMessage;
-    let promptIndex = 0;
-    let outputContinuesSent = 0;
     let thinkingObserved = false;
     let writeToolCallCount = 0;
     const observeWriterThinkingExhaustionEvidence = (event) => {
@@ -776,8 +768,6 @@ async function executeSingleSdkAttemptInternal(options) {
             resolveContextBudget?.("context-budget");
         };
         unsubscribe = session.subscribe((event) => {
-            if (event.type === "tool_execution_end" && event.isError !== true && typeof event.toolName === "string" && options.outputLimitRecovery?.terminalToolNames.includes(event.toolName) && isRecord(event.result) && isRecord(event.result.details) && event.result.details.ok === true)
-                committedTerminalObserved = true;
             if (event.type === "agent_settled" && !settled) {
                 settled = true;
                 resolveSettlement?.("settled");
@@ -798,8 +788,6 @@ async function executeSingleSdkAttemptInternal(options) {
                 }
             }
             const observationMessage = isRecord(event.message) ? event.message : undefined;
-            if (typeof observationMessage?.errorMessage === "string")
-                providerErrorMessage = observationMessage.errorMessage;
             try {
                 readObservation.observe(event);
             }
@@ -808,7 +796,7 @@ async function executeSingleSdkAttemptInternal(options) {
                 observationEvents.push({ responseId: event.responseId, messageId: event.messageId, usage: event.usage, tokenUsage: event.tokenUsage, message: observationMessage ? { role: observationMessage.role, id: observationMessage.id, responseId: observationMessage.responseId, usage: observationMessage.usage } : undefined });
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
-                usageSamples.push({ ...usageSample, responseKey: usageSample.responseKey ?? `turn-${promptIndex}` });
+                usageSamples.push(usageSample);
             if (event.type === "turn_end")
                 observedTurns += 1;
             checkContextBudget();
@@ -822,7 +810,6 @@ async function executeSingleSdkAttemptInternal(options) {
             const line = serializeSessionEvent(event);
             stdoutPreview.append(`${line}\n`);
             stdoutCollector.append(`${line}\n`);
-            turnCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
         const timeoutPromise = timeoutMs > 0
@@ -833,9 +820,6 @@ async function executeSingleSdkAttemptInternal(options) {
             })
             : null;
         const runTurn = async (userMessage) => {
-            promptIndex += 1;
-            stopReason = undefined;
-            turnCollector = createPiJsonlStreamCollector();
             const settlementPromise = resetSettlement();
             const stallPromise = resetStallPromise();
             const contextBudgetPromise = options.contextBudget
@@ -881,55 +865,44 @@ async function executeSingleSdkAttemptInternal(options) {
             : options.userMessage;
         let continuesSent = 0;
         let raced = await runTurn(promptMessage);
-        while (true) {
-            if (raced === "context-budget") {
-                appendStderr(contextBudgetDetail);
-                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
-                await disposeSession();
-            }
-            else if (raced === "stall") {
-                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
-                const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
-                const canContinue = abortConfirmed &&
-                    writeToolCallCount === 0 &&
-                    withinAbsoluteTimeout &&
-                    continuesSent < PI_SDK_STALL_CONTINUE_MAX;
-                if (canContinue) {
-                    // The aborted turn's stopReason must not leak onto a recovered continue.
-                    stopReason = undefined;
-                    continuesSent += 1;
-                    persistRuntimeNote({
-                        type: "loop-agent-stall-continue",
-                        prompt: PI_SDK_STALL_CONTINUE_PROMPT,
-                        maxContinues: PI_SDK_STALL_CONTINUE_MAX,
-                    });
-                    raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
-                    if (raced !== "done" && raced !== "settled") {
-                        await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
-                            ? "pi SDK stall continue did not recover; treating as timeout"
-                            : "pi SDK stall continue hit the absolute timeout", true);
-                    }
-                }
-                else {
-                    await failClosedAfterWait("stall", !abortConfirmed
-                        ? undefined
-                        : writeToolCallCount > 0
-                            ? "pi SDK stall continue skipped because write tools already ran"
-                            : "pi SDK stall continue skipped because absolute timeout elapsed", false);
+        if (raced === "context-budget") {
+            appendStderr(contextBudgetDetail);
+            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            await disposeSession();
+        }
+        else if (raced === "stall") {
+            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+            const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
+            const canContinue = abortConfirmed &&
+                writeToolCallCount === 0 &&
+                withinAbsoluteTimeout &&
+                continuesSent < PI_SDK_STALL_CONTINUE_MAX;
+            if (canContinue) {
+                // The aborted turn's stopReason must not leak onto a recovered continue.
+                stopReason = undefined;
+                continuesSent += 1;
+                persistRuntimeNote({
+                    type: "loop-agent-stall-continue",
+                    prompt: PI_SDK_STALL_CONTINUE_PROMPT,
+                    maxContinues: PI_SDK_STALL_CONTINUE_MAX,
+                });
+                raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
+                if (raced !== "done" && raced !== "settled") {
+                    await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
+                        ? "pi SDK stall continue did not recover; treating as timeout"
+                        : "pi SDK stall continue hit the absolute timeout", true);
                 }
             }
-            else if (raced === "absolute-timeout") {
-                await failClosedAfterWait("absolute-timeout");
-            }
-            if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !stderr && outputContinuesSent < PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX && !timedOut) {
-                outputContinuesSent += 1;
-                const note = serializeSessionEvent({ type: "loop-agent-output-limit-continue", continue: outputContinuesSent, maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX, prompt: PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT });
-                stdoutPreview.append(`${note}\n`);
-                stdoutCollector.append(`${note}\n`);
-                raced = await runTurn(PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT);
-                continue;
+            else {
+                await failClosedAfterWait("stall", !abortConfirmed
+                    ? undefined
+                    : writeToolCallCount > 0
+                        ? "pi SDK stall continue skipped because write tools already ran"
+                        : "pi SDK stall continue skipped because absolute timeout elapsed", false);
             }
-            break;
+        }
+        else if (raced === "absolute-timeout") {
+            await failClosedAfterWait("absolute-timeout");
         }
     }
     catch (error) {
@@ -958,29 +931,20 @@ async function executeSingleSdkAttemptInternal(options) {
             }
         }
     }
-    if (providerErrorMessage && stopReason === "error" && !stderr)
-        appendStderr(providerErrorMessage);
-    if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && outputContinuesSent >= PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX) {
-        const note = serializeSessionEvent({ type: "loop-agent-output-limit-exhausted", maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX });
-        stdoutPreview.append(`${note}\n`);
-    }
     const stdout = stdoutPreview.text();
     const durationMs = Date.now() - startedAt;
     const collected = stdoutCollector.finish();
     const fallbackParsed = collected.parsedEvents > 0
         ? undefined
         : extractAssistantTextFromPiJson(stdout);
-    const finalTurn = turnCollector.finish();
     const assistantText = collected.parsedEvents > 0
-        ? finalTurn.assistantText
+        ? collected.assistantText
         : (fallbackParsed?.assistantText ?? "");
     const parsedEvents = collected.parsedEvents > 0
         ? collected.parsedEvents
         : (fallbackParsed?.parsedEvents ?? 0);
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const cancelled = stopReason === "aborted";
-    const outputLimitExhausted = Boolean(options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !timedOut && !stderr);
-    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : stopReason === "aborted" ? "cancelled" : outputLimitExhausted ? "output-limit" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : terminationConfirmed
+    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : terminationConfirmed
         ? classifyPiFailure({
             assistantText,
             exitCode: timedOut ? 1 : stderr ? 1 : 0,
@@ -995,14 +959,12 @@ async function executeSingleSdkAttemptInternal(options) {
         backend: "sdk",
         command: ["pi-sdk", ...piSdkArgs],
         durationMs,
-        exitCode: timedOut || stderr || outputLimitExhausted || cancelled ? 1 : 0,
+        exitCode: timedOut || stderr ? 1 : 0,
         failureCategory,
         modelDisplay,
         ok: terminationConfirmed &&
             !timedOut &&
             !stderr &&
-            !outputLimitExhausted &&
-            !cancelled &&
             assistantText.length > 0 &&
             !collected.outputTooLarge,
         parsedEvents,

package/dist/executors/shell-executor.js

@@ -2329,7 +2329,7 @@ async function collectReviewTerminalKinds(runDir, reviewNodeId) {
             const kind = record.fact.kind;
             return typeof kind === "string" ? kind : "";
         })
-            .filter((kind) => kind === "approve_review" || kind === "request_review_changes");
+            .filter(Boolean);
     }
     catch {
         return [];
@@ -2348,7 +2348,7 @@ async function collectDesignTerminalKinds(runDir, designNodeId) {
             const kind = record.fact.kind;
             return typeof kind === "string" ? kind : "";
         })
-            .filter((kind) => kind === "approve_design" || kind === "request_design_changes");
+            .filter(Boolean);
     }
     catch {
         return [];
@@ -2974,7 +2974,6 @@ async function executeFrontendCloseout(input, meta) {
         const contract = frontendImplementationContractSchema.parse(JSON.parse(contractRaw));
         const trace = context.verificationTrace;
         const verificationTargets = (trace?.targets ?? []).map((target) => ({
-            mode: contract.verificationTargets.find((entry) => entry.id === target.id)?.mode ?? "static",
             status: target.status === "ok" ? "ok" : "failed",
         }));
         const mockEvidenceBound = contract.mockApi.strategy !== "not-needed" &&

package/dist/executors/shell-write-guard.js

@@ -94,43 +94,48 @@ const DAG_RUNS_PREFIX = ".harness/dag-runs/";
  * They are not product evidence and must not fail exclusive write guards.
  * Intentional report/product writes remain governed by writePolicy/writeSet.
  */
-const EPHEMERAL_CACHE_DIRS = [
+export function isEphemeralToolCachePath(filePath) {
+    const normalized = normalizePath(filePath);
+    if (!normalized)
+        return false;
     // CodeGraph extension sync side effect (plan 2026-08-21 D7): a loaded
     // pi-codegraph extension keeps an existing .codegraph/ index fresh at
     // session start; those index files are extension-owned run state, not
     // writer output, so they never count as write-guard violations.
-    ".codegraph",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".ruff_cache",
+    if (normalized === ".codegraph" || normalized.startsWith(".codegraph/")) {
+        return true;
+    }
+    if (normalized === ".pytest_cache" ||
+        normalized.startsWith(".pytest_cache/")) {
+        return true;
+    }
+    if (normalized === ".mypy_cache" || normalized.startsWith(".mypy_cache/")) {
+        return true;
+    }
+    if (normalized === ".ruff_cache" || normalized.startsWith(".ruff_cache/")) {
+        return true;
+    }
     // playwright-cli default session dumps (console/page/network) under repo cwd.
     // Real browser case evidence must still be written under testcase/** explicitly.
-    ".playwright-cli",
-];
-const EPHEMERAL_CACHE_DIR_PREFIXES = [
+    if (normalized === ".playwright-cli" ||
+        normalized.startsWith(".playwright-cli/")) {
+        return true;
+    }
+    if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
+        return true;
+    }
     // vite/vitest runtime caches live under node_modules/.vite (e.g.
     // node_modules/.vite/vitest/results.json). node_modules is the gitignored
     // dependency tree — tool cache writes there are never a writer's product
     // change and must not trip the write guard.
-    "node_modules/.vite",
-];
-const EPHEMERAL_CACHE_FILES = new Set([".coverage"]);
-const EPHEMERAL_CACHE_PATH_PATTERNS = [
-    /(?:^|\/)__pycache__(?:\/|$)/,
-    /\.(?:pyc|pyo)$/,
-];
-function isExactOrChildPath(value, names) {
-    return names.some((name) => value === name || value.startsWith(`${name}/`));
-}
-export function isEphemeralToolCachePath(filePath) {
-    const normalized = normalizePath(filePath);
-    if (!normalized)
-        return false;
-    return (isExactOrChildPath(normalized, EPHEMERAL_CACHE_DIRS) ||
-        EPHEMERAL_CACHE_DIR_PREFIXES.some((prefix) => normalized.startsWith(`${prefix}/`)) ||
-        EPHEMERAL_CACHE_FILES.has(normalized) ||
-        normalized.startsWith(".coverage.") ||
-        EPHEMERAL_CACHE_PATH_PATTERNS.some((pattern) => pattern.test(normalized)));
+    if (normalized.startsWith("node_modules/.vite/")) {
+        return true;
+    }
+    if (/(?:^|\/)__pycache__(?:\/|$)/.test(normalized))
+        return true;
+    if (/\.(?:pyc|pyo)$/.test(normalized))
+        return true;
+    return false;
 }
 /** MVP post-run guard: only paths that changed during the shell node are checked. */
 export function validateShellWriteGuard(input) {

package/dist/shared/pi-context-pressure/extension.js

@@ -1,4 +1,3 @@
-import { shouldRewriteAssistantTransientProviderError } from "../pi-provider-recovery.js";
 import { buildOverflowCheckpoint } from "./checkpoint.js";
 import { shouldRewriteAssistantOverflow } from "./overflow.js";
 import { clearRetrieveBypass, compressProviderPayload, createSiftRetrieveToolDefinition, SIFT_RETRIEVE_TOOL_NAME, } from "./sift-bridge.js";
@@ -12,44 +11,35 @@ export function createCompactionController() {
 export function createContextPressureExtension(options) {
     const l2 = options.policy.mode !== "off";
     const l1 = Boolean(options.sift);
-    const transientRecovery = options.normalizeTransientProviderErrors === true;
-    if (!l2 && !l1 && !transientRecovery)
+    if (!l2 && !l1)
         return undefined;
     return {
         name: options.name ?? "operator-chat-context-pressure",
         hidden: true,
         factory: (api) => {
-            if (l2 || transientRecovery) {
+            if (l2) {
                 api.on("message_end", (event) => {
                     const message = event.message;
                     if (!message || typeof message !== "object")
                         return undefined;
                     const rec = message;
-                    if (l2) {
-                        if (typeof rec.errorMessage === "string") {
-                            options.controller.lastError = rec.errorMessage;
-                        }
-                        if (rec.role === "assistant") {
-                            clearRetrieveBypassIfPresent(options.sift);
-                        }
-                        const rewritten = shouldRewriteAssistantOverflow(message);
-                        if (rewritten) {
-                            incrementCounter(options.controller.counters, "overflow");
-                            return {
-                                message: {
-                                    ...rec,
-                                    errorMessage: rewritten,
-                                },
-                            };
-                        }
+                    if (typeof rec.errorMessage === "string") {
+                        options.controller.lastError = rec.errorMessage;
                     }
-                    if (transientRecovery) {
-                        return shouldRewriteAssistantTransientProviderError(message);
+                    if (rec.role === "assistant") {
+                        clearRetrieveBypassIfPresent(options.sift);
                     }
-                    return undefined;
+                    const rewritten = shouldRewriteAssistantOverflow(message);
+                    if (!rewritten)
+                        return undefined;
+                    incrementCounter(options.controller.counters, "overflow");
+                    return {
+                        message: {
+                            ...rec,
+                            errorMessage: rewritten,
+                        },
+                    };
                 });
-            }
-            if (l2) {
                 api.on("session_before_compact", (event) => {
                     const reason = event.reason;
                     if (reason === "overflow") {

package/dist/shared/pi-retry-settings.js

@@ -21,43 +21,3 @@ export const PI_RECOMMENDED_RETRY = {
     },
 };
 export const PI_RECOMMENDED_COMPACTION = { enabled: true };
-function validBoolean(value) {
-    return typeof value === "boolean";
-}
-function validNonNegativeNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-function preferredOptionalNonNegativeNumber(...values) {
-    return values.find(validNonNegativeNumber);
-}
-function preferredValue(projectValue, globalValue, fallback, isValid) {
-    if (isValid(projectValue))
-        return projectValue;
-    if (isValid(globalValue))
-        return globalValue;
-    return fallback;
-}
-/**
- * Apply Console-owned retry defaults without writing settings files.
- * Explicit project fields win over global fields, which win over defaults.
- */
-export function applyProcessRetryOverride(manager) {
-    if (!manager?.applyOverrides)
-        return { applied: false };
-    const project = manager.getProjectSettings?.()?.retry;
-    const global = manager.getGlobalSettings?.()?.retry;
-    const currentProvider = manager.getProviderRetrySettings?.();
-    const timeoutMs = preferredOptionalNonNegativeNumber(project?.provider?.timeoutMs, global?.provider?.timeoutMs, currentProvider?.timeoutMs);
-    const retry = {
-        enabled: preferredValue(project?.enabled, global?.enabled, PI_RECOMMENDED_RETRY.enabled, validBoolean),
-        maxRetries: preferredValue(project?.maxRetries, global?.maxRetries, PI_RECOMMENDED_RETRY.maxRetries, validNonNegativeNumber),
-        baseDelayMs: preferredValue(project?.baseDelayMs, global?.baseDelayMs, PI_RECOMMENDED_RETRY.baseDelayMs, validNonNegativeNumber),
-        provider: {
-            ...(timeoutMs === undefined ? {} : { timeoutMs }),
-            maxRetries: preferredValue(project?.provider?.maxRetries, global?.provider?.maxRetries, PI_RECOMMENDED_RETRY.provider.maxRetries, validNonNegativeNumber),
-            maxRetryDelayMs: preferredValue(project?.provider?.maxRetryDelayMs, global?.provider?.maxRetryDelayMs, PI_RECOMMENDED_RETRY.provider.maxRetryDelayMs, validNonNegativeNumber),
-        },
-    };
-    manager.applyOverrides({ retry });
-    return { applied: true, retry };
-}

package/dist/shared/prompts.js

@@ -0,0 +1,26 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { isFeatureStudyTask } from './reference-context.js';
+export async function loadPrompt(repoRoot, step, taskConfig) {
+    const filename = resolvePromptFilename(step, taskConfig);
+    const promptPath = path.join(repoRoot, '.harness', 'prompts', filename);
+    try {
+        return await readFile(promptPath, 'utf-8');
+    }
+    catch {
+        if (filename !== `${step}.md`) {
+            return readFile(path.join(repoRoot, '.harness', 'prompts', `${step}.md`), 'utf-8');
+        }
+        throw new Error(`prompt not found: ${promptPath}`);
+    }
+}
+function resolvePromptFilename(step, taskConfig) {
+    if (!taskConfig || !isFeatureStudyTask(taskConfig)) {
+        return `${step}.md`;
+    }
+    if (step === 'analyze')
+        return 'feature-study-analyze.md';
+    if (step === 'plan')
+        return 'feature-study-plan.md';
+    return `${step}.md`;
+}

package/dist/task/config.js

@@ -0,0 +1,2 @@
+export * from "./config-types.js";
+export * from "./workflow-state-types.js";

package/dist/task/contract/validate-draft.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { safeParseTaskContractDraft } from "./schema.js";
+import { getTaskContractPaths } from "./paths.js";
+import { readSourceManifest } from "../source-references.js";
+function isPathOutsideRepoHint(p) {
+    if (path.isAbsolute(p))
+        return true;
+    if (p.includes("\0"))
+        return true;
+    const normalized = p.replace(/\\/g, "/");
+    if (normalized.startsWith("../") || normalized.includes("/../"))
+        return true;
+    return false;
+}
+export async function validateTaskContractDraft(input) {
+    const errors = [];
+    const warnings = [];
+    const parsed = safeParseTaskContractDraft(input.draft);
+    if (!parsed.success) {
+        for (const issue of parsed.error.issues) {
+            errors.push({
+                code: issue.message.includes("schemaVersion") ||
+                    issue.path[0] === "schemaVersion"
+                    ? "UNSUPPORTED_SCHEMA_VERSION"
+                    : "INVALID_INPUT",
+                path: issue.path.join("."),
+                message: issue.message,
+            });
+        }
+        return {
+            taskId: input.taskId,
+            valid: false,
+            errors,
+            warnings,
+        };
+    }
+    const draft = parsed.data;
+    if (draft.taskId !== input.taskId) {
+        errors.push({
+            code: "INVALID_INPUT",
+            path: "taskId",
+            message: `draft.taskId (${draft.taskId}) does not match task (${input.taskId})`,
+        });
+    }
+    for (const p of draft.constraints.allowedPaths) {
+        if (isPathOutsideRepoHint(p) && !p.includes("*")) {
+            // globs may be relative; absolute is out of repo
+            if (path.isAbsolute(p)) {
+                errors.push({
+                    code: "PATH_OUTSIDE_REPO",
+                    path: "constraints.allowedPaths",
+                    message: `absolute path not allowed: ${p}`,
+                });
+            }
+        }
+    }
+    for (const p of draft.constraints.forbiddenPaths) {
+        if (path.isAbsolute(p)) {
+            errors.push({
+                code: "PATH_OUTSIDE_REPO",
+                path: "constraints.forbiddenPaths",
+                message: `absolute path not allowed: ${p}`,
+            });
+        }
+    }
+    if (draft.references && draft.references.length > 0) {
+        const paths = getTaskContractPaths(input.repoRoot, input.taskId);
+        const manifest = await readSourceManifest(paths.sourceDir);
+        if (!manifest) {
+            warnings.push({
+                code: "MISSING_SOURCE_MANIFEST",
+                message: "draft references present but source-manifest.json is missing; import-prd first for immutable evidence",
+            });
+        }
+        else {
+            for (const ref of draft.references) {
+                const normalized = ref.ref.replace(/\\/g, "/");
+                const hit = manifest.documents.some((doc) => {
+                    const mat = doc.materializedPath.replace(/\\/g, "/");
+                    return (mat === normalized ||
+                        `source/${mat}` === normalized ||
+                        normalized.endsWith(mat));
+                });
+                if (!hit) {
+                    warnings.push({
+                        code: "REFERENCE_NOT_IN_MANIFEST",
+                        message: `reference not found in source-manifest: ${ref.ref}`,
+                    });
+                }
+            }
+        }
+    }
+    if (draft.sourceResolutions &&
+        draft.sourceResolutions.some((r) => r.decidedBy !== "human")) {
+        warnings.push({
+            code: "NON_HUMAN_SOURCE_RESOLUTION",
+            message: "one or more sourceResolutions are not decidedBy=human; blocking conflicts require human resolution before apply",
+        });
+    }
+    return {
+        taskId: input.taskId,
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/task/goal.js

@@ -0,0 +1,3 @@
+export { clearTaskGoal, consumeTaskGoalNotices, getTaskGoal, incrementGoalContinuationRuns, markTaskGoalComplete, recordTaskGoalProgress, setTaskGoal, updateTaskGoalStatus, } from "./runtime.js";
+export * from "./goal-audit.js";
+export * from "./goal-policy.js";

package/dist/task/index.js

@@ -0,0 +1,12 @@
+export * from "./ids.js";
+export * from "./paths.js";
+export * from "./source-state.js";
+export * from "./lifecycle.js";
+export * from "./goal.js";
+export * from "./subagent-guidance.js";
+export * from "./runtime.js";
+export * from "./config.js";
+export * from "./worktree.js";
+export * as taskContract from "./contract/index.js";
+export * as taskOperator from "./operator/index.js";
+export * from "./contract/index.js";

package/dist/task/lifecycle.js

@@ -0,0 +1 @@
+export { createTask, getNextStep, getSupportedNextCommand, getTaskStatus, markStepCompleted, markTaskCompleted, markTaskFailed, markTaskRunning, markVerifyGoalPending, resolveTaskFlow, shouldRunRetrospective, } from "./runtime.js";

package/dist/task/operator/capabilities.js

@@ -0,0 +1,6 @@
+/**
+ * Compatibility re-export — canonical capabilities document lives in
+ * src/shared/operator (includes Console negotiation `dag` block).
+ * No independent projection / dual implementation.
+ */
+export { buildOperatorCapabilitiesDocument, } from "../../shared/operator/capabilities.js";

package/dist/task/operator/envelope.js

@@ -0,0 +1,2 @@
+/** Compatibility re-export — canonical envelope lives in src/shared/operator. */
+export { buildOperatorResult, operatorSucceeded, operatorFailed, writeOperatorJson, processExitCodeForOutcome, } from "../../shared/operator/envelope.js";

package/dist/task/operator/index.js

@@ -0,0 +1,5 @@
+/** Compatibility barrel — re-exports src/shared/operator for task-adjacent imports. */
+export * from "./types.js";
+export * from "./envelope.js";
+export * from "./registry.js";
+export * from "./capabilities.js";

package/dist/task/operator/registry.js

@@ -0,0 +1,2 @@
+/** Compatibility re-export — canonical registry lives in src/shared/operator. */
+export { OPERATOR_OUTCOMES_V1, OPERATOR_ERROR_CODES_V1, OPERATOR_ERROR_CODE_SET, isOperatorErrorCode, } from "../../shared/operator/registry.js";

package/dist/task/operator/types.js

@@ -0,0 +1 @@
+export {};

package/dist/task/paths.js

@@ -0,0 +1 @@
+export { getTaskDir, getTaskPaths, listTaskSourceFiles, } from "./runtime.js";

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

@@ -69,7 +69,7 @@ const reviewResponseSchema = z.object({
         disposition: z.enum(FRAGMENT_DISPOSITIONS).optional(),
         reason: z.string().min(1).optional(),
     })
-        .nullish(),
+        .optional(),
 });
 /**
  * 模型队列构建镜像 semantic-intake.ts：MED→HIGH→LOW（harness executors.pi）+
@@ -134,7 +134,7 @@ function buildReviewPrompt(request) {
         "- approved: true only when the exclusion/conflict handling is justified.",
         "- fragmentId: MUST equal the requested fragment id exactly (echo the `fragment id:` line verbatim); identity mismatch is rejected.",
         "- reason: recommended; explain the verdict.",
-        "- revision: omit or use null when no revision is proposed; otherwise one bounded revision {disposition, reason}. Never invent requirements or human resolutions.",
+        "- revision: optional single bounded revision {disposition, reason}; never invent requirements or human resolutions.",
         JSON.stringify({
             fragmentId: "REQ-SRC-AB12CD34EF56",
             approved: true,