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

package/dist/shared/operator/capabilities.js

@@ -392,6 +392,147 @@ const COMMON_MUTATION_ERRORS = [
 ];
 export function buildOperatorCapabilitiesDocument() {
     const actions = [
+        {
+            action: "prepareScheduledTask", cli: "console scheduled task preparation", kind: "mutation",
+            inputSchemaVersion: 1, resultSchemaVersion: 1, envelopeSchemaVersion: 1, requiredErrorCodes: ["INVALID_INPUT"],
+            description: "Preferred entry for natural-language one-time scheduled tasks, including read-only inspection reports. Call this directly after understanding the goal, output scope, executable acceptance and time; the server uses the CURRENT project directory and creates the immutable PRD, managed Task and strict writeSet gate, binds THIS Chat automatically and returns a REAL planned goal/confirmation card. No pre-existing task, worktree or session ID is needed: never ask the user for these internal fields and do not manually create/edit them with bash/write/newTask/importPrd. Keep preparation concise: preserve the user goal without inventing extra requirements. Omit budget for ordinary tasks. Use minimal independent acceptance commands (AC-1, AC-2), preferably existing test/build scripts or test -s scheduled-report.md for a report; no compound shell/pipelines/substitution, language-specific grep checks or redundant scope assertions (the host enforces scope). Infer routine defaults and verification commands from the repository; ask only about genuinely ambiguous goal/scope/time. For read-only requests allow just an ordinary report file in the current project directory, e.g. scheduled-report.md, not .harness/. Use schedule.delayMinutes for relative time (counted after preparation finishes), or localAt + IANA timezone for an exact date/time. The current workspace must match committed HEAD; never auto-commit/stash/reset existing changes. The card exposes the exact time, bounded defaults and committed base before one human confirmation. Same request in this Chat is idempotent. Only a returned goalId with state=planned is a prepared reservation; textual drafts, Tasks or failed operations are NOT bookings. Never replace a requested schedule with immediate execution or sleep, never call runDag or self-confirm. On failure explain the returned stage, correct business inputs and retry this tool; do not mutate imported PRD/runtime artifacts. For a new distinct appointment, make its goal/time distinct.",
+            inputParams: [{ name: "request", type: "object", required: true, description: "Business goal, workflow, allowedPaths, acceptance and schedule; optional forbiddenPaths/budget. Runtime identity is server-owned." }],
+            modelCallable: "always", humanConfirmation: "none",
+        },
+        {
+            "action": "prepareScheduledGoal",
+            "cli": "console scheduled goal service",
+            "kind": "mutation",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Advanced entry ONLY for an already prepared Task. For a new natural-language reservation use prepareScheduledTask instead. Requires the current repository or its linked worktree at frozenBase and a managed Task already strict-prepared at its writeSet gate. booking must include managedTaskId, originalGoal, chatSessionRef, workflow, worktreeRef, frozenBase, allowedPaths, forbiddenPaths, acceptance {policy, criteria [{acId,description,command}]}, budget {maxTurns,maxDagRuns,maxSupervisorCalls}, time {executeAtUtc,latestStartUtc,stopAtUtc,expiresAt,timezone,allowedHours,misfirePolicy}. Resolve natural-language dates with the user timezone; ask about ambiguous time/AC/scope. No execution or authorization occurs. Show the complete scope/time/budget for one browser confirmation. Never call runDag for this reservation.",
+            "inputParams": [
+                {
+                    "name": "booking",
+                    "type": "object",
+                    "required": true,
+                    "description": "Complete frozen booking inputs; never supply prepared, controllerRef, approval or owner tokens."
+                }
+            ],
+            "modelCallable": "always",
+            "humanConfirmation": "none"
+        },
+        {
+            "action": "confirmScheduledGoal",
+            "cli": "console scheduled goal service",
+            "kind": "mutation",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Human browser confirmation of the exact displayed ScheduledGoal envelope.",
+            "inputParams": [
+                {
+                    "name": "goalId",
+                    "type": "string",
+                    "required": true,
+                    "description": "Prepared goal id"
+                },
+                {
+                    "name": "stateVersion",
+                    "type": "number",
+                    "required": true,
+                    "description": "Displayed state version"
+                },
+                {
+                    "name": "envelopeHash",
+                    "type": "string",
+                    "required": true,
+                    "description": "Displayed envelope hash"
+                }
+            ],
+            "modelCallable": "never",
+            "humanConfirmation": "required"
+        },
+        {
+            "action": "cancelScheduledGoal",
+            "cli": "console scheduled goal service",
+            "kind": "mutation",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Cancel future ScheduledGoal admission; in-flight/unknown ownership remains until reconciled.",
+            "inputParams": [
+                {
+                    "name": "goalId",
+                    "type": "string",
+                    "required": true,
+                    "description": "Goal id"
+                },
+                {
+                    "name": "stateVersion",
+                    "type": "number",
+                    "required": true,
+                    "description": "Current state version"
+                },
+                {
+                    "name": "reason",
+                    "type": "string",
+                    "required": true,
+                    "description": "Human cancellation reason"
+                }
+            ],
+            "modelCallable": "never",
+            "humanConfirmation": "required"
+        },
+        {
+            "action": "scheduledGoalGet",
+            "cli": "console scheduled goal service",
+            "kind": "read",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Read a durable ScheduledGoal booking and separate execution, acceptance, delivery and reconciliation results. Never implies authorization.",
+            "inputParams": [
+                {
+                    "name": "goalId",
+                    "type": "string",
+                    "required": true,
+                    "description": "Goal id"
+                }
+            ],
+            "modelCallable": "always",
+            "humanConfirmation": "none"
+        },
+        {
+            "action": "scheduledGoalList",
+            "cli": "console scheduled goal service",
+            "kind": "read",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "List durable ScheduledGoals, including those whose original Chat was archived or deleted.",
+            "inputParams": [
+                {
+                    "name": "chatSessionRef",
+                    "type": "string",
+                    "required": false,
+                    "description": "Optional original Chat session id"
+                }
+            ],
+            "modelCallable": "always",
+            "humanConfirmation": "none"
+        },
         {
             action: "operatorCapabilities",
             cli: "loop-agent operator capabilities --json",
@@ -714,6 +855,24 @@ export function buildOperatorCapabilitiesDocument() {
                     required: false,
                     description: "optional verify commands (label:command or shell)",
                 },
+                {
+                    name: "requirementOwnership",
+                    type: "array",
+                    required: false,
+                    description: "optional frozen requirement→file ownership for frontend-implementation DAGs: [{requirementIds, implementationFiles?, verificationFiles?}] — machine-enforced at plan finalize",
+                },
+                {
+                    name: "capabilityBoundary",
+                    type: "array",
+                    required: false,
+                    description: "optional frozen test capability boundary {allowed?, forbidden?} composed into dependencyPolicy by the runtime",
+                },
+                {
+                    name: "interactionIds",
+                    type: "array",
+                    required: false,
+                    description: "optional frozen interaction id vocabulary — contract interaction names are machine-checked against it at plan finalize",
+                },
             ],
             modelCallable: "always",
             humanConfirmation: "none",
@@ -1069,6 +1228,27 @@ export function buildOperatorCapabilitiesDocument() {
                     required: false,
                     description: "verification entries as label:command strings",
                 },
+                {
+                    name: "requirementOwnership",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "frozen requirement→file ownership: [{requirementIds, implementationFiles?, verificationFiles?}] — machine-enforced at plan finalize",
+                },
+                {
+                    name: "capabilityBoundary",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "frozen test capability boundary {allowed?, forbidden?} composed into dependencyPolicy by the runtime",
+                },
+                {
+                    name: "interactionIds",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "frozen interaction id vocabulary — contract interaction names are machine-checked against it at plan finalize",
+                },
                 {
                     name: "approveGate",
                     type: "string",

package/dist/shared/package-metadata.js

@@ -134,8 +134,10 @@ export function computePackageFingerprint(packageRoot) {
         const bBuf = Buffer.from(b.relativePath, "utf-8");
         const minLen = Math.min(aBuf.length, bBuf.length);
         for (let i = 0; i < minLen; i++) {
-            if (aBuf[i] !== bBuf[i])
-                return aBuf[i] - bBuf[i];
+            const aByte = aBuf[i];
+            const bByte = bBuf[i];
+            if (aByte !== bByte)
+                return (aByte ?? 0) - (bByte ?? 0);
         }
         return aBuf.length - bBuf.length;
     });
@@ -183,8 +185,8 @@ export function resolveBinPaths(requested, resolvedAt, inputs) {
     // Search PATH
     const pathEnv = env.PATH ?? env.Path ?? env.path ?? "";
     const candidates = resolveFromPath(requested, pathEnv, osPlatform, env.PATHEXT ?? env.Pathext ?? env.pathext, cwd);
-    if (candidates.length > 0) {
-        const entry = candidates[0];
+    const entry = candidates[0];
+    if (entry !== undefined) {
         assertRegularFile(entry, requested);
         return { requested, entry, realEntry: realpathSync(entry), resolvedAt };
     }

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

@@ -1,3 +1,4 @@
+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";
@@ -11,35 +12,44 @@ export function createCompactionController() {
 export function createContextPressureExtension(options) {
     const l2 = options.policy.mode !== "off";
     const l1 = Boolean(options.sift);
-    if (!l2 && !l1)
+    const transientRecovery = options.normalizeTransientProviderErrors === true;
+    if (!l2 && !l1 && !transientRecovery)
         return undefined;
     return {
         name: options.name ?? "operator-chat-context-pressure",
         hidden: true,
         factory: (api) => {
-            if (l2) {
+            if (l2 || transientRecovery) {
                 api.on("message_end", (event) => {
                     const message = event.message;
                     if (!message || typeof message !== "object")
                         return undefined;
                     const rec = message;
-                    if (typeof rec.errorMessage === "string") {
-                        options.controller.lastError = rec.errorMessage;
+                    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 (rec.role === "assistant") {
-                        clearRetrieveBypassIfPresent(options.sift);
+                    if (transientRecovery) {
+                        return shouldRewriteAssistantTransientProviderError(message);
                     }
-                    const rewritten = shouldRewriteAssistantOverflow(message);
-                    if (!rewritten)
-                        return undefined;
-                    incrementCounter(options.controller.counters, "overflow");
-                    return {
-                        message: {
-                            ...rec,
-                            errorMessage: rewritten,
-                        },
-                    };
+                    return undefined;
                 });
+            }
+            if (l2) {
                 api.on("session_before_compact", (event) => {
                     const reason = event.reason;
                     if (reason === "overflow") {

package/dist/shared/pi-context-pressure/sift-bridge.js

@@ -268,7 +268,7 @@ export function sliceUtf8Range(text, offset, maxBytes) {
     }
     const buffer = Buffer.from(text, "utf8");
     let end = Math.min(totalBytes, start + limit);
-    while (end > start && (buffer[end] & 0b1100_0000) === 0b1000_0000) {
+    while (end > start && ((buffer[end] ?? 0) & 0b1100_0000) === 0b1000_0000) {
         end -= 1;
     }
     const slice = buffer.subarray(start, end).toString("utf8");

package/dist/shared/pi-provider-recovery.js

@@ -0,0 +1,182 @@
+import { buildGeneratedOverflowClassifierSource, isContextOverflow, } from "./pi-context-pressure/overflow.js";
+export const NORMALIZED_TRANSIENT_PROVIDER_PREFIX = "provider returned error:";
+const ERROR_TEXT_LIMIT = 1_500;
+const PERMANENT_ERROR_PATTERNS = [
+    /\b(?:401|403|429)\b|unauthori[sz]ed|forbidden|authentication|invalid api[-_ ]?key|认证错误|鉴权失败/i,
+    /\b(?:quota|billing|insufficient.?credit|out of budget)\b|余额不足|配额(?:不足|耗尽)/i,
+    /rate.?limit|too many requests|请求.{0,8}(?:频繁|过多)|频率.{0,8}限制|限流/i,
+    /aborted by user|user cancel|cancelled|canceled|用户取消/i,
+    /business validation|invalid task|schema validation|业务校验/i,
+];
+export const BUILT_IN_TRANSIENT_PROVIDER_RULES = Object.freeze([
+    Object.freeze({
+        id: "wrapped-transient-provider-error",
+        all: Object.freeze([
+            /\b(?:UnknownError|TypeValidationError)\b|Type validation failed/i,
+        ]),
+        any: Object.freeze([
+            /\b502\b|\bcode[:\s]*502\b/i,
+            /\bLLMRequestError\b/i,
+            /network fluctuation|timeout|model processing timeout/i,
+            /网络波动|模型处理超时|当前请求超时/i,
+            /transient provider failure|non-standard (?:payload|response)|upstream returned/i,
+        ]),
+    }),
+    Object.freeze({
+        id: "internal-llm-request-error",
+        all: Object.freeze([/\bLLMRequestError\b/i]),
+        any: Object.freeze([
+            /\b502\b|\bcode[:\s]*502\b/i,
+            /network fluctuation|timeout|model processing timeout/i,
+            /网络波动|模型处理超时|当前请求超时/i,
+            /non-standard (?:payload|response)|upstream returned/i,
+        ]),
+    }),
+    Object.freeze({
+        id: "internal-provider-fluctuation",
+        any: Object.freeze([/网络波动|模型处理超时|当前请求超时/i]),
+    }),
+]);
+function stringifyErrorPart(value) {
+    if (typeof value === "string")
+        return value;
+    if (value == null)
+        return "";
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function errorText(error) {
+    if (typeof error === "string")
+        return error;
+    if (error == null)
+        return "";
+    if (typeof error !== "object")
+        return String(error);
+    const record = error;
+    return [
+        stringifyErrorPart(record.name),
+        stringifyErrorPart(record.message),
+        stringifyErrorPart(record.status),
+        stringifyErrorPart(record.code),
+        stringifyErrorPart(record.data),
+        stringifyErrorPart(error),
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function patternMatches(pattern, text) {
+    pattern.lastIndex = 0;
+    const matched = pattern.test(text);
+    pattern.lastIndex = 0;
+    return matched;
+}
+function ruleMatches(rule, text) {
+    const all = rule.all ?? [];
+    const any = rule.any ?? [];
+    if (all.length === 0 && any.length === 0)
+        return false;
+    if (!all.every((pattern) => patternMatches(pattern, text)))
+        return false;
+    return any.length === 0 || any.some((pattern) => patternMatches(pattern, text));
+}
+function isPermanentProviderError(error, text) {
+    if (isContextOverflow(error))
+        return true;
+    return PERMANENT_ERROR_PATTERNS.some((pattern) => patternMatches(pattern, text));
+}
+export function classifyTransientProviderError(error, options = {}) {
+    const text = errorText(error);
+    if (!text || isPermanentProviderError(error, text)) {
+        return { retryable: false, reason: "permanent" };
+    }
+    const rules = [
+        ...BUILT_IN_TRANSIENT_PROVIDER_RULES,
+        ...(options.additionalRules ?? []),
+    ];
+    const matched = rules.find((rule) => ruleMatches(rule, text));
+    return matched
+        ? { retryable: true, ruleId: matched.id }
+        : { retryable: false, reason: "no-match" };
+}
+export function normalizeTransientProviderErrorMessage(current, options = {}) {
+    if (!current || current.startsWith(NORMALIZED_TRANSIENT_PROVIDER_PREFIX)) {
+        return undefined;
+    }
+    if (!classifyTransientProviderError(current, options).retryable)
+        return undefined;
+    const bounded = current.length <= ERROR_TEXT_LIMIT
+        ? current
+        : `${current.slice(0, ERROR_TEXT_LIMIT - 1)}…`;
+    return `${NORMALIZED_TRANSIENT_PROVIDER_PREFIX} ${bounded}`;
+}
+export function shouldRewriteAssistantTransientProviderError(message, options = {}) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    const record = message;
+    if (record.role !== "assistant")
+        return undefined;
+    if (record.stopReason !== undefined && record.stopReason !== "error") {
+        return undefined;
+    }
+    const current = typeof record.errorMessage === "string" ? record.errorMessage : "";
+    const rewritten = normalizeTransientProviderErrorMessage(current, options);
+    return rewritten
+        ? { message: { ...record, errorMessage: rewritten } }
+        : undefined;
+}
+function serializePatterns(patterns) {
+    return JSON.stringify(patterns.map((pattern) => ({ source: pattern.source, flags: pattern.flags })));
+}
+/** Generate the pure predicate embedded in the project-level OpenCode plugin. */
+export function buildGeneratedTransientProviderClassifierSource() {
+    const rules = BUILT_IN_TRANSIENT_PROVIDER_RULES.map((rule) => ({
+        id: rule.id,
+        all: (rule.all ?? []).map((pattern) => ({
+            source: pattern.source,
+            flags: pattern.flags,
+        })),
+        any: (rule.any ?? []).map((pattern) => ({
+            source: pattern.source,
+            flags: pattern.flags,
+        })),
+    }));
+    return `${buildGeneratedOverflowClassifierSource()}
+const TRANSIENT_PROVIDER_PERMANENT_PATTERNS = ${serializePatterns(PERMANENT_ERROR_PATTERNS)};
+const TRANSIENT_PROVIDER_RULES = ${JSON.stringify(rules)};
+function transientProviderStringify(value) {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+function transientProviderText(error) {
+  if (typeof error === "string") return error;
+  if (error == null) return "";
+  if (typeof error !== "object") return String(error);
+  return [
+    transientProviderStringify(error.name),
+    transientProviderStringify(error.message),
+    transientProviderStringify(error.status),
+    transientProviderStringify(error.code),
+    transientProviderStringify(error.data),
+    transientProviderStringify(error),
+  ].filter(Boolean).join(" ");
+}
+function transientProviderPatternMatches(pattern, text) {
+  return new RegExp(pattern.source, pattern.flags).test(text);
+}
+function transientProviderRuleMatches(rule, text) {
+  if (rule.all.length === 0 && rule.any.length === 0) return false;
+  if (!rule.all.every((pattern) => transientProviderPatternMatches(pattern, text))) return false;
+  return rule.any.length === 0 || rule.any.some((pattern) => transientProviderPatternMatches(pattern, text));
+}
+function isKnownTransientProviderError(error) {
+  const text = transientProviderText(error);
+  if (!text || isOverflowMessage(text)) return false;
+  if (TRANSIENT_PROVIDER_PERMANENT_PATTERNS.some((pattern) => transientProviderPatternMatches(pattern, text))) return false;
+  return TRANSIENT_PROVIDER_RULES.some((rule) => transientProviderRuleMatches(rule, text));
+}`;
+}

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

@@ -21,3 +21,43 @@ 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/reference-context.js

@@ -186,6 +186,8 @@ function globToRegExp(glob) {
     let regex = '^';
     for (let i = 0; i < glob.length; i += 1) {
         const char = glob[i];
+        if (char === undefined)
+            continue;
         if (char === '*') {
             const next = glob[i + 1];
             if (next === '*') {

package/dist/task/config-types.js

@@ -286,6 +286,35 @@ const taskConfigObjectSchema = z.object({
     verifyPreset: verifyPresetSchema.optional().default("auto"),
     /** Task-contract commands that must be included in final DAG shell verification. */
     verifyCommands: z.array(taskVerifyCommandSchema).optional().default([]),
+    /** Generation-frozen requirement→file ownership for frontend-implementation
+     * DAGs. Machine-checked at plan finalize: a requirement's implementation
+     * targets (and its verification targets' files) must stay inside the
+     * declared sets, so ownership never depends on model compliance with prose.
+     */
+    requirementOwnership: z
+        .array(z
+        .object({
+        requirementIds: z.array(z.string().min(1)).min(1),
+        implementationFiles: z.array(z.string().min(1)).optional(),
+        verificationFiles: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .refine((entry) => (entry.implementationFiles?.length ?? 0) > 0 ||
+        (entry.verificationFiles?.length ?? 0) > 0, { message: "requirementOwnership entry needs implementationFiles or verificationFiles" }))
+        .optional(),
+    /** Generation-frozen test capability boundary composed into the canonical
+     * dependencyPolicy by the runtime (planner never maintains it). */
+    capabilityBoundary: z
+        .object({
+        allowed: z.array(z.string().min(1)).optional(),
+        forbidden: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .refine((entry) => (entry.allowed?.length ?? 0) > 0 || (entry.forbidden?.length ?? 0) > 0, { message: "capabilityBoundary needs allowed or forbidden entries" })
+        .optional(),
+    /** Generation-frozen interaction id vocabulary. Contract interaction names
+     * must come from this set (plan finalize deterministic check). */
+    interactionIds: z.array(z.string().min(1)).optional(),
     /** Verification selection policy. Intermediate loops may use quota; final gates still run full required verification. */
     verifyQuota: verifyQuotaSchema.optional().default("full"),
     /** DAG supervised verify strategy. Final quota is fixed to full; intermediate quota may reduce cost. */

package/dist/task/contract/project.js

@@ -187,6 +187,15 @@ export function mergeManagedTaskConfigFields(existing, draft) {
         ...(draft.frontendOpenspec !== undefined
             ? { frontendOpenspec: draft.frontendOpenspec }
             : {}),
+        ...(draft.requirementOwnership !== undefined
+            ? { requirementOwnership: draft.requirementOwnership }
+            : {}),
+        ...(draft.capabilityBoundary !== undefined
+            ? { capabilityBoundary: draft.capabilityBoundary }
+            : {}),
+        ...(draft.interactionIds !== undefined
+            ? { interactionIds: draft.interactionIds }
+            : {}),
     };
     if (draft.featureId !== undefined) {
         next.featureId = draft.featureId;

package/dist/task/contract/recover.js

@@ -70,6 +70,12 @@ export async function recoverTaskContract(input) {
             };
         }
         const txId = input.txId ?? unfinished[0];
+        if (txId === undefined) {
+            return {
+                action: "manual-required",
+                message: "no unfinished transactions to recover",
+            };
+        }
         if (!unfinished.includes(txId)) {
             return {
                 action: "manual-required",

package/dist/task/contract/schema.js

@@ -75,6 +75,23 @@ export const taskContractDraftSchema = z
     assumptions: z.array(z.string()).optional(),
     hardConstraints: z.array(z.string()).optional(),
     frontendOpenspec: frontendOpenspecConfigSchema.optional(),
+    requirementOwnership: z
+        .array(z
+        .object({
+        requirementIds: z.array(z.string().min(1)).min(1),
+        implementationFiles: z.array(z.string().min(1)).optional(),
+        verificationFiles: z.array(z.string().min(1)).optional(),
+    })
+        .strict())
+        .optional(),
+    capabilityBoundary: z
+        .object({
+        allowed: z.array(z.string().min(1)).optional(),
+        forbidden: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .optional(),
+    interactionIds: z.array(z.string().min(1)).optional(),
     interviewAssessmentRef: z
         .object({
         draftSha256: z.string().min(1),

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

@@ -17,7 +17,10 @@ function parseSimpleFrontmatter(block) {
         const match = /^([A-Za-z0-9_-]+)\s*:\s*(.+?)\s*$/u.exec(line);
         if (!match)
             continue;
-        out[match[1]] = parseYamlishScalar(match[2]);
+        const [, key, value] = match;
+        if (key === undefined || value === undefined)
+            continue;
+        out[key] = parseYamlishScalar(value);
     }
     return out;
 }
@@ -46,7 +49,11 @@ export function detectProductArtifactMeta(markdown) {
     if (!match) {
         return { artifactType: "unknown", recognized: false };
     }
-    const fields = parseSimpleFrontmatter(match[1]);
+    const [, frontmatter] = match;
+    if (frontmatter === undefined) {
+        return { artifactType: "unknown", recognized: false };
+    }
+    const fields = parseSimpleFrontmatter(frontmatter);
     const artifactType = normalizeArtifactType(fields.artifact_type);
     const recognized = artifactType !== "unknown" || Boolean(fields.artifact_version);
     return {