@skein-code/cli 0.3.9 → 0.3.10

package/dist/cli.js

@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.9",
+  version: "0.3.10",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,9 +236,9 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
-      "First-run context preparation now shows the real inspect, build, persist, and verify stages",
-      "Fresh sessions add a compact Skein identity and grouped workspace rail without filling the terminal",
-      "Short and narrow terminals collapse the index handoff while preserving validation and recovery states"
+      "Complex executable requests now use a durable Task Contract with evidence-bound acceptance criteria",
+      "Completion stays unverified while required acceptance or final verification remains unresolved",
+      "Structured tool failure receipts add concise repair hints, retry budgets, cancellation handling, and identical-call circuit breaking"
     ]
   },
   bin: {
@@ -3279,7 +3279,7 @@ function formatContextHits(hits, roots) {
 }
 
 // src/agent/runner.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 
 // src/context/manager.ts
 var RECENT_TURN_RESERVE = 3;
@@ -4974,6 +4974,19 @@ var lastRunSchema = z5.object({
   checks: z5.array(verificationEvidenceSchema),
   detail: z5.string(),
   mutationTracking: z5.enum(["complete", "unknown"]).optional(),
+  acceptance: z5.object({
+    state: z5.enum(["draft", "active", "satisfied", "blocked"]),
+    total: z5.number().int().nonnegative(),
+    satisfied: z5.number().int().nonnegative(),
+    pending: z5.number().int().nonnegative(),
+    blocked: z5.number().int().nonnegative(),
+    missingVerification: z5.array(z5.string()),
+    unresolved: z5.array(z5.object({
+      id: z5.string(),
+      description: z5.string(),
+      status: z5.enum(["pending", "satisfied", "blocked"])
+    }).strict())
+  }).strict().optional(),
   reason: z5.string(),
   finishedAt: z5.string()
 }).strict();
@@ -4986,6 +4999,27 @@ var workingMemorySchema = z5.object({
   relevantFiles: z5.array(z5.string()),
   lastUpdatedAt: z5.string()
 }).strict();
+var taskContractCriterionSchema = z5.object({
+  id: z5.string().min(1).max(128),
+  description: z5.string().min(1).max(2e3),
+  required: z5.boolean(),
+  status: z5.enum(["pending", "satisfied", "blocked"]),
+  evidenceRefs: z5.array(z5.string().min(1).max(256)).max(64),
+  note: z5.string().max(2e3).optional()
+}).strict();
+var taskContractSchema = z5.object({
+  version: z5.literal(1),
+  state: z5.enum(["draft", "active", "satisfied", "blocked"]),
+  objective: z5.string().min(1).max(2e4),
+  scope: z5.array(z5.string().min(1).max(2e3)).max(64),
+  constraints: z5.array(z5.string().min(1).max(2e3)).max(64),
+  nonGoals: z5.array(z5.string().min(1).max(2e3)).max(64),
+  acceptanceCriteria: z5.array(taskContractCriterionSchema).min(1).max(64),
+  verificationRequirements: z5.array(z5.string().min(1).max(2e3)).max(64),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  auditBoundaryId: z5.string().min(1).max(128).optional()
+}).strict();
 var sessionSchema = z5.object({
   id: sessionIdSchema,
   title: z5.string(),
@@ -5003,6 +5037,7 @@ var sessionSchema = z5.object({
   compactedThroughMessageId: z5.string().optional(),
   workingMemory: workingMemorySchema.optional(),
   contextSources: z5.array(contextSourceSchema).max(64).optional(),
+  taskContract: taskContractSchema.optional(),
   lastRun: lastRunSchema.optional(),
   usage: z5.object({
     inputTokens: z5.number().nonnegative(),
@@ -6751,120 +6786,91 @@ var taskTool = {
   }
 };
 
-// src/tools/working-memory.ts
+// src/tools/task-contract.ts
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { z as z13 } from "zod";
-var inputSchema9 = z13.discriminatedUnion("action", [
-  z13.object({ action: z13.literal("show") }).strict(),
-  z13.object({ action: z13.literal("set_goal"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("set_focus"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_constraint"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_decision"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_question"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("resolve_question"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_file"), path: z13.string().min(1).max(4e3) }).strict(),
-  z13.object({ action: z13.literal("clear"), field: z13.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
-]);
-var workingMemoryTool = {
-  definition: {
-    name: "working_memory",
-    description: "Read or update short-term thread state: goal, focus, constraints, decisions, open questions, and relevant files. This state is temporary and is not durable memory.",
-    category: "read",
-    inputSchema: jsonSchema({
-      action: { type: "string", enum: [
-        "show",
-        "set_goal",
-        "set_focus",
-        "add_constraint",
-        "add_decision",
-        "add_question",
-        "resolve_question",
-        "add_file",
-        "clear"
-      ] },
-      value: { type: "string", description: "Text for a goal, focus, constraint, decision, or question." },
-      path: { type: "string", description: "Workspace-relative relevant file path." },
-      field: { type: "string", enum: ["constraints", "decisions", "openQuestions", "relevantFiles"] }
-    }, ["action"])
-  },
-  async execute(arguments_, context) {
-    const input2 = inputSchema9.parse(arguments_);
-    const memory = context.session.workingMemory ?? emptyWorkingMemory2();
-    switch (input2.action) {
-      case "show":
-        break;
-      case "set_goal":
-        memory.goal = clean(input2.value);
-        break;
-      case "set_focus":
-        memory.focus = clean(input2.value);
-        break;
-      case "add_constraint":
-        pushBounded2(memory.constraints, input2.value, 12);
-        break;
-      case "add_decision":
-        pushBounded2(memory.decisions, input2.value, 12);
-        break;
-      case "add_question":
-        pushBounded2(memory.openQuestions, input2.value, 12);
-        break;
-      case "resolve_question":
-        removeMatching(memory.openQuestions, input2.value);
-        break;
-      case "add_file": {
-        const safe = await context.workspace.resolvePath(input2.path, { expect: "any" });
-        pushBounded2(memory.relevantFiles, safe, 24);
-        break;
-      }
-      case "clear":
-        memory[input2.field] = [];
-        break;
-    }
-    memory.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    context.session.workingMemory = memory;
-    return { content: render(memory), metadata: { workingMemory: { ...memory } } };
-  }
-};
-function emptyWorkingMemory2() {
+
+// src/agent/task-contract.ts
+import { randomUUID as randomUUID10 } from "node:crypto";
+var EXECUTABLE_INTENTS = /* @__PURE__ */ new Set(["debug", "refactor", "test", "implement"]);
+function shouldUseTaskContract(request, intent, existing) {
+  if (existing && existing.state !== "satisfied") return true;
+  if (!EXECUTABLE_INTENTS.has(intent)) return false;
+  const value = request.trim();
+  if (value.length < 180) return false;
+  const requirements = value.split(/(?:\n+|[；;。]\s*|\b(?:and|then|also|plus)\b|以及|并且|同时|还要|另外)/iu).filter((item) => item.trim().length >= 12);
+  const complexitySignals = [
+    /\b(?:refactor|migrate|redesign|architecture|end[- ]to[- ]end|across|multiple)\b/iu,
+    /重构|迁移|架构|完整|全链路|多个|跨模块|兼容|同时/iu,
+    /(?:^|\n)\s*(?:[-*]|\d+[.)、])\s+/mu
+  ].filter((pattern) => pattern.test(value)).length;
+  return requirements.length >= 3 || complexitySignals >= 2 || value.length >= 500;
+}
+function createDraftTaskContract(request, auditBoundaryId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const objective = compact(request, 2e3);
   return {
-    goal: "",
-    focus: "",
-    constraints: [],
-    decisions: [],
-    openQuestions: [],
-    relevantFiles: [],
-    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    version: 1,
+    state: "draft",
+    objective,
+    scope: ["Configured workspace roots and the files required by the objective."],
+    constraints: [
+      "Preserve unrelated user changes.",
+      "Use successful tool evidence for acceptance claims."
+    ],
+    nonGoals: [],
+    acceptanceCriteria: [
+      criterion("requested-outcome", `Implement the requested outcome: ${compact(request, 500)}`),
+      criterion("verification", "Run the smallest relevant deterministic verification after the final mutation.")
+    ],
+    verificationRequirements: [
+      "Record at least one successful test, typecheck, lint, build, check, or diff check after the final mutation."
+    ],
+    createdAt: now,
+    updatedAt: now,
+    ...auditBoundaryId ? { auditBoundaryId } : {}
   };
 }
-function pushBounded2(values, value, limit) {
-  const normalized = clean(value);
-  const existing = values.indexOf(normalized);
-  if (existing >= 0) values.splice(existing, 1);
-  values.push(normalized);
-  if (values.length > limit) values.splice(0, values.length - limit);
+function successfulContractEvidence(session) {
+  const refs = /* @__PURE__ */ new Set();
+  const contract = session.taskContract;
+  if (!contract) return refs;
+  for (const event of eventsSinceContract(session.audit ?? [], contract)) {
+    if (event.type !== "tool" || event.outcome !== "success") continue;
+    if (event.tool === "task_contract" || event.tool === "task" || event.tool === "working_memory") continue;
+    refs.add(event.id);
+    refs.add(event.toolCallId);
+  }
+  return refs;
 }
-function removeMatching(values, value) {
-  const query = value.toLocaleLowerCase().trim();
-  for (let index = values.length - 1; index >= 0; index -= 1) {
-    const candidate = values[index];
-    if (candidate.toLocaleLowerCase() === query || candidate.toLocaleLowerCase().includes(query)) {
-      values.splice(index, 1);
-    }
+function eventsSinceContract(audit, contract) {
+  if (contract.auditBoundaryId) {
+    const boundary = audit.findIndex((event) => event.id === contract.auditBoundaryId);
+    if (boundary >= 0) return audit.slice(boundary + 1);
   }
+  return audit.filter((event) => event.createdAt >= contract.createdAt);
 }
-function clean(value) {
-  return value.trim().replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/g, "[redacted-secret]").replace(/\b((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret))\s*[:=]\s*[^\s,;]+/gi, "$1=[redacted]").replace(/\s+/g, " ").slice(0, 1e3);
+function refreshTaskContractState(contract) {
+  const required = contract.acceptanceCriteria.filter((item) => item.required);
+  contract.state = required.some((item) => item.status === "blocked") ? "blocked" : required.length > 0 && required.every((item) => item.status === "satisfied") ? "satisfied" : "active";
+  contract.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 }
-function render(memory) {
-  return [
-    `Goal: ${memory.goal || "(none)"}`,
-    `Focus: ${memory.focus || "(none)"}`,
-    `Constraints: ${memory.constraints.length ? memory.constraints.join(" \xB7 ") : "(none)"}`,
-    `Decisions: ${memory.decisions.length ? memory.decisions.join(" \xB7 ") : "(none)"}`,
-    `Open questions: ${memory.openQuestions.length ? memory.openQuestions.join(" \xB7 ") : "(none)"}`,
-    `Relevant files: ${memory.relevantFiles.length ? memory.relevantFiles.join(" \xB7 ") : "(none)"}`
-  ].join("\n");
+function criterion(id, description) {
+  return {
+    id: `${id}-${randomUUID10().slice(0, 8)}`,
+    description,
+    required: true,
+    status: "pending",
+    evidenceRefs: []
+  };
+}
+function compact(value, limit) {
+  return value.trim().replace(/\s+/gu, " ").slice(0, limit);
 }
 
+// src/agent/completion-gate.ts
+import { createHash as createHash9 } from "node:crypto";
+
 // src/tools/permissions.ts
 import { createHash as createHash8, createHmac, randomBytes } from "node:crypto";
 var permissionScopeSecret = randomBytes(32);
@@ -7025,27 +7031,529 @@ function normalizeFullUrl(value) {
     return normalized.slice(0, 8e3);
   }
 }
-function scopeFingerprint(value) {
-  return createHmac("sha256", permissionScopeSecret).update(stableScopeValue(value)).digest("hex").slice(0, 24);
+function scopeFingerprint(value) {
+  return createHmac("sha256", permissionScopeSecret).update(stableScopeValue(value)).digest("hex").slice(0, 24);
+}
+function stableScopeValue(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return `string:${JSON.stringify(value)}`;
+  if (typeof value === "number") return `number:${String(value)}`;
+  if (typeof value === "boolean") return `boolean:${String(value)}`;
+  if (typeof value === "undefined") return "undefined";
+  if (Array.isArray(value)) return `array:[${value.map(stableScopeValue).join(",")}]`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableScopeValue(item)}`);
+    return `object:{${entries.join(",")}}`;
+  }
+  return `${typeof value}:${String(value)}`;
+}
+function containsShellControl(command2) {
+  return /(?:[;&|<>`\n\r]|\$\(|\$\{)/.test(command2);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/agent/completion-gate.ts
+function captureVerification(call, result, changeSequence, configuredCommands) {
+  if (call.name !== "shell" && call.name !== "git") return void 0;
+  const command2 = commandForCall(call);
+  if (!command2) return void 0;
+  const normalized = normalizeCommand2(command2);
+  const configured = new Set(configuredCommands.map(normalizeCommand2));
+  const kind = configured.has(normalized) ? "configured" : classifyVerificationCommand(normalized);
+  if (!kind) return void 0;
+  return {
+    toolCallId: call.id,
+    tool: call.name,
+    command: redactCommand(command2),
+    kind,
+    ok: result.ok,
+    changeSequence,
+    commandKey: createHash9("sha256").update(normalized).digest("hex")
+  };
+}
+function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete", taskContract, audit = []) {
+  const files = [...new Set(changedFiles)];
+  const acceptance = taskContract ? buildAcceptance(taskContract, audit, evidence, currentChangeSequence) : void 0;
+  if (mutationTracking === "unknown") {
+    return {
+      status: "unverified",
+      changedFiles: files,
+      checks: [],
+      detail: files.length ? `Workspace changes were observed, but a dynamic shell command prevented complete mutation tracking for ${fileCount(files.length)}.` : "A dynamic shell command may have changed workspace files, but reliable mutation tracking was unavailable.",
+      mutationTracking,
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "unverified") } : {}
+    };
+  }
+  if (!files.length) {
+    if (acceptance && acceptanceUnresolved(acceptance)) {
+      return {
+        status: "unverified",
+        changedFiles: [],
+        checks: [],
+        detail: acceptanceDetail(acceptance),
+        acceptance: acceptanceForCompletion(acceptance, "unverified")
+      };
+    }
+    return {
+      status: "no_changes",
+      changedFiles: [],
+      checks: [],
+      detail: "No workspace files changed in this run.",
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "no_changes") } : {}
+    };
+  }
+  const latestByCommand = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    if (item.changeSequence === currentChangeSequence) {
+      latestByCommand.set(item.commandKey, item);
+    }
+  }
+  const checks = [...latestByCommand.values()].map(publicEvidence);
+  if (!checks.length) {
+    return {
+      status: "unverified",
+      changedFiles: files,
+      checks,
+      detail: `No successful verification was recorded after the last change to ${fileCount(files.length)}.`,
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "unverified") } : {}
+    };
+  }
+  const failures = checks.filter((check) => !check.ok);
+  if (failures.length) {
+    return {
+      status: "verification_failed",
+      changedFiles: files,
+      checks,
+      detail: `${failures.length} of ${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} failed.`,
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "verification_failed") } : {}
+    };
+  }
+  if (acceptance && acceptanceUnresolved(acceptance)) {
+    return {
+      status: "unverified",
+      changedFiles: files,
+      checks,
+      detail: acceptanceDetail(acceptance),
+      acceptance: acceptanceForCompletion(acceptance, "unverified")
+    };
+  }
+  return {
+    status: "verified",
+    changedFiles: files,
+    checks,
+    detail: `${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} passed for ${fileCount(files.length)}.`,
+    ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "verified") } : {}
+  };
+}
+function completionRecoveryDirective(completion) {
+  if (completion.acceptance && acceptanceUnresolved(completion.acceptance)) {
+    const unresolved = completion.acceptance.unresolved.map((item) => `- [${item.status}] ${item.id}: ${item.description}`).join("\n");
+    const failed = completion.checks.filter((check) => !check.ok).map((check) => `- ${check.command} (tool call ${check.toolCallId})`).join("\n");
+    return `<runtime-completion-gate status="acceptance_unresolved" authorization="none">
+The run cannot be marked complete while required Task Contract criteria remain unresolved:
+${unresolved || "- Acceptance criteria are satisfied."}${completion.acceptance.missingVerification.length ? `
+Missing required verification:
+${completion.acceptance.missingVerification.map((item) => `- ${item}`).join("\n")}` : ""}${failed ? `
+Current failed checks:
+${failed}` : ""}
+Complete or explicitly block only these criteria. Mark a criterion satisfied through task_contract only with successful tool audit evidence or a successful tool-call id. Run the smallest missing verification after the final mutation. Do not repeat the final summary or claim acceptance from prose alone.
+</runtime-completion-gate>`;
+  }
+  if (completion.status === "verification_failed") {
+    const failed = completion.checks.filter((check) => !check.ok).map((check) => `- ${check.command} (tool call ${check.toolCallId})`).join("\n");
+    return `<runtime-completion-gate status="verification_failed" authorization="none">
+The run cannot be marked complete because current verification failed:
+${failed}
+Inspect the recorded tool output, correct the underlying problem, and rerun the smallest relevant check. Do not repeat the final summary or claim success without a new successful tool result. If the failure cannot be resolved safely, state the exact blocker and leave the result unverified.
+</runtime-completion-gate>`;
+  }
+  const changeSummary = completion.mutationTracking === "unknown" ? "A dynamic shell command could not be mapped to a complete set of workspace changes." : `The run changed ${fileCount(completion.changedFiles.length)}, but no successful verification command was recorded after the last change.`;
+  return `<runtime-completion-gate status="unverified" authorization="none">
+${changeSummary}
+Run the smallest relevant test, typecheck, lint, build, or git diff --check now. Do not repeat the final summary or claim a check passed without a successful tool result. If verification cannot be run safely, state the exact reason and leave the result unverified.
+</runtime-completion-gate>`;
+}
+function buildAcceptance(contract, audit, evidence, currentChangeSequence) {
+  const contractEvents = eventsSinceContract(audit, contract);
+  const successfulEvents = contractEvents.filter(
+    (event) => event.type === "tool" && event.outcome === "success" && event.tool !== "task_contract" && event.tool !== "task" && event.tool !== "working_memory"
+  );
+  const latestMutationIndex = contractEvents.reduce((latest, event, index) => {
+    const changedFiles = event.metadata?.changedFiles;
+    return Array.isArray(changedFiles) && changedFiles.length > 0 ? index : latest;
+  }, -1);
+  const successfulRefs = /* @__PURE__ */ new Map();
+  for (const event of successfulEvents) {
+    const index = contractEvents.indexOf(event);
+    successfulRefs.set(event.id, { event, index });
+    successfulRefs.set(event.toolCallId, { event, index });
+  }
+  const required = contract.acceptanceCriteria.filter((item) => item.required);
+  const normalized = required.map((item) => {
+    const evidenceValid = item.evidenceRefs.some((ref) => {
+      const event = successfulRefs.get(ref);
+      return event !== void 0 && event.index >= latestMutationIndex;
+    });
+    const status = item.status === "satisfied" && !evidenceValid ? "pending" : item.status;
+    return { id: item.id, description: item.description, status };
+  });
+  const satisfied = normalized.filter((item) => item.status === "satisfied").length;
+  const pending = normalized.filter((item) => item.status === "pending").length;
+  const blocked = normalized.filter((item) => item.status === "blocked").length;
+  const currentChecks = evidence.filter((item) => item.changeSequence === currentChangeSequence && item.ok);
+  const requirements = contract.verificationRequirements.length ? contract.verificationRequirements : ["Record at least one successful test, typecheck, lint, build, check, or diff check after the final mutation."];
+  const missingVerification = requirements.filter(
+    (requirement) => !verificationRequirementMet(requirement, currentChecks)
+  );
+  return {
+    state: contract.state === "draft" ? "draft" : blocked > 0 ? "blocked" : pending > 0 || missingVerification.length > 0 ? "active" : "satisfied",
+    total: normalized.length,
+    satisfied,
+    pending,
+    blocked,
+    missingVerification,
+    unresolved: normalized.filter((item) => item.status !== "satisfied")
+  };
+}
+function acceptanceDetail(acceptance) {
+  const parts = [
+    acceptance.pending ? `${acceptance.pending} pending` : "",
+    acceptance.blocked ? `${acceptance.blocked} blocked` : "",
+    acceptance.missingVerification.length ? `${acceptance.missingVerification.length} verification requirements missing` : ""
+  ].filter(Boolean).join(" and ");
+  const unresolved = acceptance.pending + acceptance.blocked;
+  return `Task Contract acceptance is unresolved: ${parts} required ${unresolved === 1 ? "criterion" : "criteria"}.`;
+}
+function verificationRequirementMet(requirement, checks) {
+  const normalized = normalizeCommand2(requirement);
+  const broad = normalized.match(/^Record at least one successful (.+) after the final mutation\.?$/iu);
+  if (broad) return checks.length > 0;
+  const commandKey = createHash9("sha256").update(normalized).digest("hex");
+  return checks.some((item) => item.commandKey === commandKey);
+}
+function acceptanceUnresolved(acceptance) {
+  return acceptance.pending > 0 || acceptance.blocked > 0 || acceptance.missingVerification.length > 0;
+}
+function acceptanceForCompletion(acceptance, status) {
+  if (acceptance.state === "draft" || acceptance.state === "blocked" || status === "verified" || status === "no_changes") return acceptance;
+  return acceptance.state === "active" ? acceptance : { ...acceptance, state: "active" };
+}
+function classifyVerificationCommand(command2) {
+  const normalized = normalizeCommand2(command2).toLocaleLowerCase();
+  const segments = normalized.split(/\s*(?:&&|\|\||;)\s*/u).filter(Boolean);
+  if (segments.length > 1) {
+    const kinds = segments.map(classifySingleVerificationCommand);
+    if (kinds.every((kind) => kind !== void 0)) {
+      return kinds.every((kind) => kind === kinds[0]) ? kinds[0] : "check";
+    }
+    return void 0;
+  }
+  return classifySingleVerificationCommand(normalized);
+}
+function classifySingleVerificationCommand(command2) {
+  const value = command2.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)+/u, "");
+  if (/^git\s+diff\b.*(?:^|\s)--check(?:\s|$)/u.test(value)) return "diff";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test(?::[^\s]+)?|test|vitest|jest)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:vitest|jest)(?:\s|$)/u.test(value) || /^(?:python(?:\d+(?:\.\d+)*)?\s+-m\s+)?pytest(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^node\s+--test(?:\s|$)/u.test(value)) return "test";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:typecheck|type-check|check:types)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^cargo\s+check(?:\s|$)/u.test(value)) return "typecheck";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?lint(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:eslint|biome|ruff)(?:\s|$)/u.test(value) || /^(?:eslint|biome\s+check|ruff\s+check|cargo\s+clippy)(?:\s|$)/u.test(value)) return "lint";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:build|compile)(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+build(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:build|compile)(?:\s|$)/u.test(value)) return "build";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?check(?:\s|$)/u.test(value) || /^(?:make|just|task|gradle|gradlew)\s+check(?:\s|$)/u.test(value)) return "check";
+  return void 0;
+}
+function publicEvidence(item) {
+  return {
+    toolCallId: item.toolCallId,
+    tool: item.tool,
+    command: item.command,
+    kind: item.kind,
+    ok: item.ok
+  };
+}
+function normalizeCommand2(command2) {
+  return command2.trim().replace(/[\t ]+/gu, " ");
+}
+function redactCommand(command2) {
+  return command2.replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\b((?:api[_-]?key|access[_-]?token|authorization|password|secret|token))\s*=\s*([^\s]+)/giu, "$1=[redacted]").replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/gu, "[redacted-secret]").trim().slice(0, 2e3);
+}
+function fileCount(count) {
+  return `${count} workspace ${count === 1 ? "file" : "files"}`;
+}
+
+// src/tools/task-contract.ts
+var criterionSchema = z13.object({
+  id: z13.string().min(1).max(128).optional(),
+  description: z13.string().min(1).max(2e3),
+  required: z13.boolean().optional()
+}).strict();
+var inputSchema9 = z13.discriminatedUnion("action", [
+  z13.object({ action: z13.literal("show") }).strict(),
+  z13.object({
+    action: z13.literal("replace"),
+    objective: z13.string().min(1).max(2e4),
+    scope: z13.array(z13.string().min(1).max(2e3)).max(64),
+    constraints: z13.array(z13.string().min(1).max(2e3)).max(64),
+    non_goals: z13.array(z13.string().min(1).max(2e3)).max(64),
+    acceptance_criteria: z13.array(criterionSchema).min(1).max(64),
+    verification_requirements: z13.array(z13.string().min(1).max(2e3)).min(1).max(64)
+  }).strict(),
+  z13.object({ action: z13.literal("activate") }).strict(),
+  z13.object({
+    action: z13.literal("update_criterion"),
+    id: z13.string().min(1).max(128),
+    status: z13.enum(["pending", "satisfied", "blocked"]),
+    evidence_refs: z13.array(z13.string().min(1).max(256)).max(64).optional(),
+    note: z13.string().max(2e3).optional()
+  }).strict()
+]);
+var taskContractTool = {
+  definition: {
+    name: "task_contract",
+    description: "Define and update the durable acceptance contract for a complex executable request. Satisfied criteria require successful tool audit evidence IDs or tool-call IDs.",
+    category: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["show", "replace", "activate", "update_criterion"] },
+        objective: { type: "string" },
+        scope: { type: "array", items: { type: "string" } },
+        constraints: { type: "array", items: { type: "string" } },
+        non_goals: { type: "array", items: { type: "string" } },
+        acceptance_criteria: { type: "array", items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            description: { type: "string" },
+            required: { type: "boolean" }
+          },
+          required: ["description"],
+          additionalProperties: false
+        } },
+        verification_requirements: {
+          type: "array",
+          minItems: 1,
+          items: { type: "string" },
+          description: "Required verification commands or the standard any-successful-check requirement."
+        },
+        id: { type: "string" },
+        status: { type: "string", enum: ["pending", "satisfied", "blocked"] },
+        evidence_refs: { type: "array", items: { type: "string" } },
+        note: { type: "string" }
+      },
+      required: ["action"],
+      additionalProperties: false
+    }
+  },
+  async execute(arguments_, context) {
+    const input2 = inputSchema9.parse(arguments_);
+    let contract = context.session.taskContract;
+    if (!contract) throw new Error("No Task Contract is active for this session.");
+    if (input2.action === "replace") {
+      if (contract.state !== "draft") {
+        throw new Error("Only a draft Task Contract can be replaced.");
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const criteria = input2.acceptance_criteria.map((item) => ({
+        id: item.id ?? `criterion-${randomUUID11().slice(0, 8)}`,
+        description: item.description,
+        required: item.required ?? true,
+        status: "pending",
+        evidenceRefs: []
+      }));
+      if (new Set(criteria.map((item) => item.id)).size !== criteria.length) {
+        throw new Error("Task Contract criterion ids must be unique.");
+      }
+      if (!criteria.some((item) => item.required)) {
+        throw new Error("Task Contract requires at least one required acceptance criterion.");
+      }
+      for (const existing of contract.acceptanceCriteria.filter((item) => item.required)) {
+        const retained = criteria.find((item) => item.id === existing.id);
+        if (!retained || !retained.required || retained.description !== existing.description) {
+          throw new Error(`Required criterion cannot be removed or weakened: ${existing.id}`);
+        }
+      }
+      for (const existing of contract.verificationRequirements) {
+        if (!input2.verification_requirements.includes(existing)) {
+          throw new Error(`Verification requirement cannot be removed: ${existing}`);
+        }
+      }
+      for (const requirement of input2.verification_requirements) {
+        validateVerificationRequirement(requirement);
+      }
+      Object.assign(contract, {
+        version: 1,
+        state: "active",
+        objective: input2.objective,
+        scope: input2.scope,
+        constraints: input2.constraints,
+        nonGoals: input2.non_goals,
+        acceptanceCriteria: criteria,
+        verificationRequirements: input2.verification_requirements,
+        createdAt: contract.createdAt,
+        updatedAt: now,
+        ...contract.auditBoundaryId ? { auditBoundaryId: contract.auditBoundaryId } : {}
+      });
+    } else if (input2.action === "activate") {
+      refreshTaskContractState(contract);
+    } else if (input2.action === "update_criterion") {
+      if (contract.state === "draft") {
+        throw new Error("Activate the draft Task Contract before updating acceptance criteria.");
+      }
+      const criterion2 = contract.acceptanceCriteria.find((item) => item.id === input2.id);
+      if (!criterion2) throw new Error(`Unknown Task Contract criterion id: ${input2.id}`);
+      const refs = [...new Set(input2.evidence_refs ?? [])];
+      if (input2.status === "satisfied") {
+        if (!refs.length) throw new Error("Satisfied criteria require at least one evidence_refs entry.");
+        const valid = successfulContractEvidence(context.session);
+        const invalid = refs.filter((ref) => !valid.has(ref));
+        if (invalid.length) {
+          throw new Error(`Unknown or unsuccessful evidence refs: ${invalid.join(", ")}`);
+        }
+      }
+      criterion2.status = input2.status;
+      criterion2.evidenceRefs = input2.status === "satisfied" ? refs : [];
+      if (input2.note === void 0) delete criterion2.note;
+      else criterion2.note = input2.note;
+      refreshTaskContractState(contract);
+    }
+    return {
+      content: formatContract(contract),
+      metadata: { taskContract: structuredClone(contract) }
+    };
+  }
+};
+function formatContract(contract) {
+  const satisfied = contract.acceptanceCriteria.filter((item) => item.status === "satisfied").length;
+  const criteria = contract.acceptanceCriteria.map(
+    (item) => `- [${item.status}] ${item.id}: ${item.description}`
+  ).join("\n");
+  return `Task Contract: ${contract.state} (${satisfied}/${contract.acceptanceCriteria.length} satisfied)
+Objective: ${contract.objective}
+${criteria}`;
+}
+function validateVerificationRequirement(requirement) {
+  if (/^Record at least one successful (.+) after the final mutation\.?$/iu.test(requirement)) return;
+  if (/\b(?:api[_-]?key|authorization|password|secret|token)\s*=/iu.test(requirement)) {
+    throw new Error("Verification requirements cannot contain credentials.");
+  }
+  if (!classifyVerificationCommand(requirement)) {
+    throw new Error(`Verification requirement is not a recognized deterministic check: ${requirement}`);
+  }
+}
+
+// src/tools/working-memory.ts
+import { z as z14 } from "zod";
+var inputSchema10 = z14.discriminatedUnion("action", [
+  z14.object({ action: z14.literal("show") }).strict(),
+  z14.object({ action: z14.literal("set_goal"), value: z14.string().min(1).max(1e3) }).strict(),
+  z14.object({ action: z14.literal("set_focus"), value: z14.string().min(1).max(1e3) }).strict(),
+  z14.object({ action: z14.literal("add_constraint"), value: z14.string().min(1).max(1e3) }).strict(),
+  z14.object({ action: z14.literal("add_decision"), value: z14.string().min(1).max(1e3) }).strict(),
+  z14.object({ action: z14.literal("add_question"), value: z14.string().min(1).max(1e3) }).strict(),
+  z14.object({ action: z14.literal("resolve_question"), value: z14.string().min(1).max(1e3) }).strict(),
+  z14.object({ action: z14.literal("add_file"), path: z14.string().min(1).max(4e3) }).strict(),
+  z14.object({ action: z14.literal("clear"), field: z14.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
+]);
+var workingMemoryTool = {
+  definition: {
+    name: "working_memory",
+    description: "Read or update short-term thread state: goal, focus, constraints, decisions, open questions, and relevant files. This state is temporary and is not durable memory.",
+    category: "read",
+    inputSchema: jsonSchema({
+      action: { type: "string", enum: [
+        "show",
+        "set_goal",
+        "set_focus",
+        "add_constraint",
+        "add_decision",
+        "add_question",
+        "resolve_question",
+        "add_file",
+        "clear"
+      ] },
+      value: { type: "string", description: "Text for a goal, focus, constraint, decision, or question." },
+      path: { type: "string", description: "Workspace-relative relevant file path." },
+      field: { type: "string", enum: ["constraints", "decisions", "openQuestions", "relevantFiles"] }
+    }, ["action"])
+  },
+  async execute(arguments_, context) {
+    const input2 = inputSchema10.parse(arguments_);
+    const memory = context.session.workingMemory ?? emptyWorkingMemory2();
+    switch (input2.action) {
+      case "show":
+        break;
+      case "set_goal":
+        memory.goal = clean(input2.value);
+        break;
+      case "set_focus":
+        memory.focus = clean(input2.value);
+        break;
+      case "add_constraint":
+        pushBounded2(memory.constraints, input2.value, 12);
+        break;
+      case "add_decision":
+        pushBounded2(memory.decisions, input2.value, 12);
+        break;
+      case "add_question":
+        pushBounded2(memory.openQuestions, input2.value, 12);
+        break;
+      case "resolve_question":
+        removeMatching(memory.openQuestions, input2.value);
+        break;
+      case "add_file": {
+        const safe = await context.workspace.resolvePath(input2.path, { expect: "any" });
+        pushBounded2(memory.relevantFiles, safe, 24);
+        break;
+      }
+      case "clear":
+        memory[input2.field] = [];
+        break;
+    }
+    memory.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    context.session.workingMemory = memory;
+    return { content: render(memory), metadata: { workingMemory: { ...memory } } };
+  }
+};
+function emptyWorkingMemory2() {
+  return {
+    goal: "",
+    focus: "",
+    constraints: [],
+    decisions: [],
+    openQuestions: [],
+    relevantFiles: [],
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function pushBounded2(values, value, limit) {
+  const normalized = clean(value);
+  const existing = values.indexOf(normalized);
+  if (existing >= 0) values.splice(existing, 1);
+  values.push(normalized);
+  if (values.length > limit) values.splice(0, values.length - limit);
 }
-function stableScopeValue(value) {
-  if (value === null) return "null";
-  if (typeof value === "string") return `string:${JSON.stringify(value)}`;
-  if (typeof value === "number") return `number:${String(value)}`;
-  if (typeof value === "boolean") return `boolean:${String(value)}`;
-  if (typeof value === "undefined") return "undefined";
-  if (Array.isArray(value)) return `array:[${value.map(stableScopeValue).join(",")}]`;
-  if (typeof value === "object") {
-    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableScopeValue(item)}`);
-    return `object:{${entries.join(",")}}`;
+function removeMatching(values, value) {
+  const query = value.toLocaleLowerCase().trim();
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    const candidate = values[index];
+    if (candidate.toLocaleLowerCase() === query || candidate.toLocaleLowerCase().includes(query)) {
+      values.splice(index, 1);
+    }
   }
-  return `${typeof value}:${String(value)}`;
 }
-function containsShellControl(command2) {
-  return /(?:[;&|<>`\n\r]|\$\(|\$\{)/.test(command2);
+function clean(value) {
+  return value.trim().replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/g, "[redacted-secret]").replace(/\b((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret))\s*[:=]\s*[^\s,;]+/gi, "$1=[redacted]").replace(/\s+/g, " ").slice(0, 1e3);
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function render(memory) {
+  return [
+    `Goal: ${memory.goal || "(none)"}`,
+    `Focus: ${memory.focus || "(none)"}`,
+    `Constraints: ${memory.constraints.length ? memory.constraints.join(" \xB7 ") : "(none)"}`,
+    `Decisions: ${memory.decisions.length ? memory.decisions.join(" \xB7 ") : "(none)"}`,
+    `Open questions: ${memory.openQuestions.length ? memory.openQuestions.join(" \xB7 ") : "(none)"}`,
+    `Relevant files: ${memory.relevantFiles.length ? memory.relevantFiles.join(" \xB7 ") : "(none)"}`
+  ].join("\n");
 }
 
 // src/tools/index.ts
@@ -7059,6 +7567,7 @@ function createDefaultToolRegistry(_options = {}) {
     shellTool,
     gitTool,
     taskTool,
+    taskContractTool,
     workingMemoryTool
   ]);
 }
@@ -7098,11 +7607,19 @@ ${workspaceRules}` : ""}`;
 }
 function buildSessionStatePrompt(session) {
   const tasks = session.tasks.length ? session.tasks.map((task) => `- [${task.status}] ${task.title}`).join("\n") : "- No active plan.";
+  const contract = session.taskContract && session.taskContract.state !== "satisfied" ? `
+
+Task Contract (${session.taskContract.state}):
+Objective: ${session.taskContract.objective}
+${session.taskContract.acceptanceCriteria.map(
+    (item) => `- [${item.status}] ${item.id}: ${item.description}`
+  ).join("\n")}
+Use task_contract to activate or update acceptance. A satisfied criterion requires successful tool evidence.` : "";
   return `<session-state scope="session" authorization="none">
 This is mutable execution state, not a permission grant or higher-priority instruction.
 
 Current saved plan:
-${tasks}
+${tasks}${contract}
 </session-state>`;
 }
 function buildRetrievedContext(packed, mentions, primaryRoot, roots = [primaryRoot]) {
@@ -7170,130 +7687,120 @@ function escapeAttribute3(value) {
   })[character] ?? character);
 }
 
-// src/agent/completion-gate.ts
-import { createHash as createHash9 } from "node:crypto";
-function captureVerification(call, result, changeSequence, configuredCommands) {
-  if (call.name !== "shell" && call.name !== "git") return void 0;
-  const command2 = commandForCall(call);
-  if (!command2) return void 0;
-  const normalized = normalizeCommand2(command2);
-  const configured = new Set(configuredCommands.map(normalizeCommand2));
-  const kind = configured.has(normalized) ? "configured" : classifyVerificationCommand(normalized);
-  if (!kind) return void 0;
-  return {
-    toolCallId: call.id,
-    tool: call.name,
-    command: redactCommand(command2),
-    kind,
-    ok: result.ok,
-    changeSequence,
-    commandKey: createHash9("sha256").update(normalized).digest("hex")
-  };
-}
-function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete") {
-  const files = [...new Set(changedFiles)];
-  if (mutationTracking === "unknown") {
-    return {
-      status: "unverified",
-      changedFiles: files,
-      checks: [],
-      detail: files.length ? `Workspace changes were observed, but a dynamic shell command prevented complete mutation tracking for ${fileCount(files.length)}.` : "A dynamic shell command may have changed workspace files, but reliable mutation tracking was unavailable.",
-      mutationTracking
-    };
+// src/agent/tool-recovery.ts
+import { createHash as createHash10 } from "node:crypto";
+var RETRY_BUDGET = {
+  schema_input: 3,
+  unknown_tool: 2,
+  permission_denied: 0,
+  command_exit: 3,
+  timeout: 2,
+  cancelled: 0,
+  hook: 1,
+  execution: 3,
+  contract_required: 2
+};
+var REPAIR_HINT = {
+  schema_input: "Correct the arguments to match the tool schema.",
+  unknown_tool: "Choose a tool exposed for this turn.",
+  permission_denied: "Do not retry unless the user or configuration changes permission.",
+  command_exit: "Inspect the exit output, change the command or fix the cause, then retry once.",
+  timeout: "Narrow the operation or increase its allowed timeout.",
+  cancelled: "Stop work and preserve the current state.",
+  hook: "Fix the hook failure before relying on the tool result.",
+  execution: "Use the error detail to change the inputs or approach.",
+  contract_required: "Activate the Task Contract before any workspace mutation."
+};
+var ToolRecoveryController = class {
+  signatures = /* @__PURE__ */ new Map();
+  classFailures = /* @__PURE__ */ new Map();
+  toolClasses = /* @__PURE__ */ new Map();
+  preflight(call) {
+    const callKey = callSignature(call);
+    const signatureState = this.signatures.get(callKey);
+    if (signatureState && (signatureState.failures >= 2 || !isRetryable(signatureState.failureClass))) {
+      return this.receipt(
+        call,
+        signatureState.failureClass,
+        signatureState.failures + 1,
+        true
+      );
+    }
+    const lastClass = this.toolClasses.get(call.name);
+    if (lastClass && (this.classFailures.get(lastClass) ?? 0) >= RETRY_BUDGET[lastClass] && RETRY_BUDGET[lastClass] > 0) {
+      return this.receipt(call, lastClass, (signatureState?.failures ?? 0) + 1, true);
+    }
+    return void 0;
   }
-  if (!files.length) {
-    return {
-      status: "no_changes",
-      changedFiles: [],
-      checks: [],
-      detail: "No workspace files changed in this run."
-    };
+  recordFailure(call, failureClass) {
+    const callKey = callSignature(call);
+    const current = this.signatures.get(callKey);
+    const failures = current?.failureClass === failureClass ? current.failures + 1 : 1;
+    this.signatures.set(callKey, { failureClass, failures });
+    this.toolClasses.set(call.name, failureClass);
+    this.classFailures.set(failureClass, (this.classFailures.get(failureClass) ?? 0) + 1);
+    return this.receipt(
+      call,
+      failureClass,
+      failures,
+      failures >= 2 || !isRetryable(failureClass)
+    );
   }
-  const latestByCommand = /* @__PURE__ */ new Map();
-  for (const item of evidence) {
-    if (item.changeSequence === currentChangeSequence) {
-      latestByCommand.set(item.commandKey, item);
-    }
+  recordSuccess(call) {
+    this.signatures.delete(callSignature(call));
+    this.toolClasses.delete(call.name);
   }
-  const checks = [...latestByCommand.values()].map(publicEvidence);
-  if (!checks.length) {
+  receipt(call, failureClass, attempt, circuitOpen) {
+    const budget = RETRY_BUDGET[failureClass];
+    const consumed = this.classFailures.get(failureClass) ?? 0;
     return {
-      status: "unverified",
-      changedFiles: files,
-      checks,
-      detail: `No successful verification was recorded after the last change to ${fileCount(files.length)}.`
+      class: failureClass,
+      retryable: isRetryable(failureClass) && consumed < budget && !circuitOpen,
+      repairHint: REPAIR_HINT[failureClass],
+      attempt,
+      remaining: Math.max(0, budget - consumed),
+      circuitOpen,
+      signature: failureSignature(call, failureClass)
     };
   }
-  const failures = checks.filter((check) => !check.ok);
-  if (failures.length) {
-    return {
-      status: "verification_failed",
-      changedFiles: files,
-      checks,
-      detail: `${failures.length} of ${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} failed.`
-    };
+};
+function classifyToolFailure(result, fallback = "execution") {
+  if (result.metadata?.failureClass && isFailureClass(result.metadata.failureClass)) {
+    return result.metadata.failureClass;
   }
-  return {
-    status: "verified",
-    changedFiles: files,
-    checks,
-    detail: `${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} passed for ${fileCount(files.length)}.`
-  };
-}
-function completionRecoveryDirective(completion) {
-  if (completion.status === "verification_failed") {
-    const failed = completion.checks.filter((check) => !check.ok).map((check) => `- ${check.command} (tool call ${check.toolCallId})`).join("\n");
-    return `<runtime-completion-gate status="verification_failed" authorization="none">
-The run cannot be marked complete because current verification failed:
-${failed}
-Inspect the recorded tool output, correct the underlying problem, and rerun the smallest relevant check. Do not repeat the final summary or claim success without a new successful tool result. If the failure cannot be resolved safely, state the exact blocker and leave the result unverified.
-</runtime-completion-gate>`;
+  if (result.metadata?.aborted === true) return "cancelled";
+  if (result.metadata?.timedOut === true) return "timeout";
+  if (result.metadata?.hookError) return "hook";
+  if (typeof result.metadata?.exitCode === "number" && result.metadata.exitCode !== 0) {
+    return "command_exit";
   }
-  const changeSummary = completion.mutationTracking === "unknown" ? "A dynamic shell command could not be mapped to a complete set of workspace changes." : `The run changed ${fileCount(completion.changedFiles.length)}, but no successful verification command was recorded after the last change.`;
-  return `<runtime-completion-gate status="unverified" authorization="none">
-${changeSummary}
-Run the smallest relevant test, typecheck, lint, build, or git diff --check now. Do not repeat the final summary or claim a check passed without a successful tool result. If verification cannot be run safely, state the exact reason and leave the result unverified.
-</runtime-completion-gate>`;
+  return fallback;
 }
-function classifyVerificationCommand(command2) {
-  const normalized = normalizeCommand2(command2).toLocaleLowerCase();
-  const segments = normalized.split(/\s*(?:&&|\|\||;)\s*/u).filter(Boolean);
-  if (segments.length > 1) {
-    const kinds = segments.map(classifySingleVerificationCommand);
-    if (kinds.every((kind) => kind !== void 0)) {
-      return kinds.every((kind) => kind === kinds[0]) ? kinds[0] : "check";
-    }
-    return void 0;
-  }
-  return classifySingleVerificationCommand(normalized);
+function formatFailureReceipt(receipt) {
+  return `Failure: ${receipt.class}; attempt ${receipt.attempt}; ${receipt.remaining} retries remain; circuit ${receipt.circuitOpen ? "open" : "closed"}. Repair: ${receipt.repairHint}`;
 }
-function classifySingleVerificationCommand(command2) {
-  const value = command2.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)+/u, "");
-  if (/^git\s+diff\b.*(?:^|\s)--check(?:\s|$)/u.test(value)) return "diff";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test(?::[^\s]+)?|test|vitest|jest)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:vitest|jest)(?:\s|$)/u.test(value) || /^(?:python(?:\d+(?:\.\d+)*)?\s+-m\s+)?pytest(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^node\s+--test(?:\s|$)/u.test(value)) return "test";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:typecheck|type-check|check:types)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^cargo\s+check(?:\s|$)/u.test(value)) return "typecheck";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?lint(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:eslint|biome|ruff)(?:\s|$)/u.test(value) || /^(?:eslint|biome\s+check|ruff\s+check|cargo\s+clippy)(?:\s|$)/u.test(value)) return "lint";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:build|compile)(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+build(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:build|compile)(?:\s|$)/u.test(value)) return "build";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?check(?:\s|$)/u.test(value) || /^(?:make|just|task|gradle|gradlew)\s+check(?:\s|$)/u.test(value)) return "check";
-  return void 0;
+function isRetryable(failureClass) {
+  return RETRY_BUDGET[failureClass] > 0;
 }
-function publicEvidence(item) {
-  return {
-    toolCallId: item.toolCallId,
-    tool: item.tool,
-    command: item.command,
-    kind: item.kind,
-    ok: item.ok
-  };
+function callSignature(call) {
+  return createHash10("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}`).digest("hex");
 }
-function normalizeCommand2(command2) {
-  return command2.trim().replace(/[\t ]+/gu, " ");
+function failureSignature(call, failureClass) {
+  return createHash10("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}\0${failureClass}`).digest("hex");
 }
-function redactCommand(command2) {
-  return command2.replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\b((?:api[_-]?key|access[_-]?token|authorization|password|secret|token))\s*=\s*([^\s]+)/giu, "$1=[redacted]").replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/gu, "[redacted-secret]").trim().slice(0, 2e3);
+function redact(value, key = "") {
+  if (/api[_-]?key|authorization|cookie|password|secret|token/i.test(key)) return "[redacted]";
+  if (Array.isArray(value)) return value.map((item) => redact(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([name, item]) => [name, redact(item, name)]));
+  }
+  return value;
 }
-function fileCount(count) {
-  return `${count} workspace ${count === 1 ? "file" : "files"}`;
+function stableJson(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+function isFailureClass(value) {
+  return typeof value === "string" && Object.hasOwn(RETRY_BUDGET, value);
 }
 
 // src/agent/rules.ts
@@ -7538,6 +8045,8 @@ var AgentRunner = class {
     const changeSequenceAtStart = this.changeSequence;
     const runChangedFiles = /* @__PURE__ */ new Set();
     const verificationEvidence = [];
+    const toolRecovery = new ToolRecoveryController();
+    let activeRunContract = this.session.taskContract;
     let mutationTracking = "complete";
     let completionRecoveryAttempted = false;
     const recordExecution = (call, result) => {
@@ -7556,12 +8065,21 @@ var AgentRunner = class {
       );
       if (evidence) verificationEvidence.push(evidence);
     };
-    const completionReport = () => buildRunCompletion(
-      runChangedFiles,
-      verificationEvidence,
-      this.changeSequence,
-      mutationTracking
-    );
+    const completionReport = () => {
+      const completion = buildRunCompletion(
+        runChangedFiles,
+        verificationEvidence,
+        this.changeSequence,
+        mutationTracking,
+        activeRunContract,
+        this.session.audit ?? []
+      );
+      if (completion.acceptance && activeRunContract && activeRunContract.state !== "draft") {
+        activeRunContract.state = completion.acceptance.state;
+        activeRunContract.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return completion;
+    };
     const finishRun = async (reason, completion = completionReport()) => {
       this.session.lastRun = {
         ...completion,
@@ -7569,6 +8087,10 @@ var AgentRunner = class {
         finishedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       await this.persist();
+      const finalContract = activeRunContract && structuredClone(activeRunContract);
+      if (finalContract && finalContract.state !== "satisfied") {
+        await emit({ type: "contract", contract: finalContract });
+      }
       await emit({ type: "done", reason, completion });
       return this.session;
     };
@@ -7613,10 +8135,22 @@ var AgentRunner = class {
       const turnDirective = buildTurnDirective(request, {
         agents: Boolean(this.config.agents?.enabled)
       });
+      const contractEnabled = shouldUseTaskContract(
+        request,
+        turnDirective.intent,
+        this.session.taskContract
+      );
+      if (contractEnabled && (!this.session.taskContract || this.session.taskContract.state === "satisfied")) {
+        this.session.taskContract = createDraftTaskContract(request, this.session.audit?.at(-1)?.id);
+        await this.persist();
+        await emit({ type: "contract", contract: structuredClone(this.session.taskContract) });
+      }
+      activeRunContract = contractEnabled ? this.session.taskContract : void 0;
       const promptSections = [
         `intent:${turnDirective.intent}`,
         ...workspaceRules ? ["rules"] : [],
         ...this.session.workingMemory ? ["working-memory"] : [],
+        ...contractEnabled ? ["task-contract"] : [],
         ...this.session.contextSummary ? ["session-summary"] : [],
         ...!trivialTurn ? [`context:${packed.engine}`] : [],
         ...packed.text ? [`code:${packed.engine}`] : [],
@@ -7669,7 +8203,7 @@ var AgentRunner = class {
         );
         const availableTokens = this.config.agent.maxSessionTokens - (this.session.usage.inputTokens + this.session.usage.outputTokens);
         const estimatedInputTokens = estimateMessages2(messages) + estimateToolDefinitions(
-          options.askMode ? this.tools.definitions().filter((tool) => tool.category === "read") : this.tools.definitions()
+          visibleToolDefinitions(this.tools, options.askMode === true, contractEnabled)
         );
         if (availableTokens <= 0 || estimatedInputTokens >= availableTokens) {
           return finishRun("token_budget");
@@ -7678,8 +8212,8 @@ var AgentRunner = class {
           this.config.model.maxTokens ?? 8192,
           availableTokens - estimatedInputTokens
         ));
-        const visibleTools = options.askMode ? this.tools.definitions().filter((tool) => tool.category === "read") : this.tools.definitions();
-        const assistantId = randomUUID10();
+        const visibleTools = visibleToolDefinitions(this.tools, options.askMode === true, contractEnabled);
+        const assistantId = randomUUID12();
         const response = await this.completeModel(
           messages,
           visibleTools,
@@ -7722,9 +8256,17 @@ var AgentRunner = class {
           return finishRun("token_budget");
         }
         if (response.toolCalls.length) {
+          const visibleToolNames = new Set(visibleTools.map((tool) => tool.name));
           for (const call of response.toolCalls) {
             throwIfAborted(options.signal);
-            const result = await this.executeTool(call, options, emit);
+            const result = await this.executeTool(
+              call,
+              options,
+              emit,
+              toolRecovery,
+              visibleToolNames
+            );
+            if (call.name === "task_contract") activeRunContract = this.session.taskContract;
             recordExecution(call, result);
             this.session.messages.push(message("tool", result.content, {
               toolCallId: result.toolCallId,
@@ -7753,8 +8295,11 @@ Review these results, correct any failures if needed, then provide the final ans
           continue;
         }
         const completion = completionReport();
-        if (this.config.agent.autoVerify && (completion.status === "unverified" || completion.status === "verification_failed") && !completionRecoveryAttempted && turn < maxTurns) {
+        if ((this.config.agent.autoVerify || Boolean(completion.acceptance)) && (completion.status === "unverified" || completion.status === "verification_failed") && !completionRecoveryAttempted && turn < maxTurns) {
           completionRecoveryAttempted = true;
+          if (activeRunContract) {
+            await emit({ type: "contract", contract: structuredClone(activeRunContract) });
+          }
           this.session.messages.push(message("user", completionRecoveryDirective(completion)));
           await this.persist();
           await this.runAfterTurnHook(turn, [], options.signal);
@@ -7822,10 +8367,29 @@ ${input2}`
     if (final) return final;
     return { content, toolCalls: [] };
   }
-  async executeTool(call, options, emit) {
+  async executeTool(call, options, emit, recovery = new ToolRecoveryController(), visibleToolNames) {
+    const preflight = recovery.preflight(call);
+    if (preflight) {
+      const result = failedResult(call, "Tool call rejected by the recovery circuit.", preflight);
+      this.recordToolResult(result);
+      await emit({ type: "tool_result", result });
+      return result;
+    }
+    if (visibleToolNames && !visibleToolNames.has(call.name)) {
+      const receipt = recovery.recordFailure(call, "unknown_tool");
+      const result = failedResult(
+        call,
+        `Tool is not exposed for this turn: ${call.name}`,
+        receipt
+      );
+      this.recordToolResult(result);
+      await emit({ type: "tool_result", result });
+      return result;
+    }
     const tool = this.tools.get(call.name);
     if (!tool) {
-      const result = failedResult(call, `Unknown tool: ${call.name}`);
+      const receipt = recovery.recordFailure(call, "unknown_tool");
+      const result = failedResult(call, `Unknown tool: ${call.name}`, receipt);
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
       return result;
@@ -7836,7 +8400,20 @@ ${input2}`
         tool.permissionCategories?.(call.arguments) ?? [tool.definition.category]
       );
     } catch (error) {
-      const result = failedResult(call, formatToolError(error));
+      const failureClass = classifyThrownToolFailure(error, options.signal);
+      const receipt = recovery.recordFailure(call, failureClass);
+      const result = failedResult(call, formatToolError(error), receipt);
+      this.recordToolResult(result, tool.definition.category);
+      await emit({ type: "tool_result", result });
+      return result;
+    }
+    if (categories.some((category) => category !== "read") && this.session.taskContract?.state === "draft") {
+      const receipt = recovery.recordFailure(call, "contract_required");
+      const result = failedResult(
+        call,
+        "Potentially mutating work is paused until the draft Task Contract is activated.",
+        receipt
+      );
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
@@ -7844,7 +8421,8 @@ ${input2}`
     for (const category of categories) {
       const allowed = await this.authorize(call, category, options, emit);
       if (!allowed) {
-        const result = failedResult(call, `Permission denied for ${category} operation.`);
+        const receipt = recovery.recordFailure(call, "permission_denied");
+        const result = failedResult(call, `Permission denied for ${category} operation.`, receipt);
         this.recordToolResult(result, category);
         await emit({ type: "tool_result", result });
         return result;
@@ -7906,15 +8484,30 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
           ...afterHookError ? { toolSucceeded: true, hookError: afterHookError.message } : {}
         }
       };
+      if (!result.ok) {
+        const failureClass = options.signal?.aborted ? "cancelled" : classifyToolFailure(result);
+        const receipt = recovery.recordFailure(call, failureClass);
+        result.content = truncateToolOutput(`${formatFailureReceipt(receipt)}
+${result.content}`);
+        result.metadata = { ...result.metadata, failure: receipt };
+      } else {
+        recovery.recordSuccess(call);
+      }
       this.contextManager.recordTool(this.session, call, result);
       if (JSON.stringify(this.session.tasks) !== tasksBefore || call.name === "task") {
         await emit({ type: "tasks", tasks: this.session.tasks.map((task) => ({ ...task })) });
       }
+      if (call.name === "task_contract" && this.session.taskContract) {
+        await emit({ type: "contract", contract: structuredClone(this.session.taskContract) });
+      }
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
     } catch (error) {
-      const result = failedResult(call, formatToolError(error));
+      const normalized = toError(error);
+      const failureClass = classifyThrownToolFailure(normalized, options.signal);
+      const receipt = recovery.recordFailure(call, failureClass);
+      const result = failedResult(call, formatToolError(error), receipt);
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
@@ -7983,7 +8576,7 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
   }
   appendAudit(event) {
     const audit = this.session.audit ?? (this.session.audit = []);
-    audit.push({ id: randomUUID10(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...event });
+    audit.push({ id: randomUUID12(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...event });
     if (audit.length > 5e3) audit.splice(0, audit.length - 5e3);
   }
   async acceptChangedFiles(paths) {
@@ -8004,7 +8597,7 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
     const results = [];
     for (const command2 of this.config.agent.verifyCommands) {
       const call = {
-        id: `verify-${randomUUID10()}`,
+        id: `verify-${randomUUID12()}`,
         name: "shell",
         arguments: { command: command2, cwd: this.workspace.primaryRoot }
       };
@@ -8071,7 +8664,7 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
 };
 function message(role, content, extra = {}) {
   return {
-    id: randomUUID10(),
+    id: randomUUID12(),
     role,
     content,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8142,14 +8735,21 @@ function estimateResponseTokens(response) {
 function uniqueCategories(categories) {
   return [...new Set(categories)];
 }
-function failedResult(call, content) {
+function failedResult(call, content, failure) {
   return {
     toolCallId: call.id,
     name: call.name,
     ok: false,
-    content: truncateToolOutput(content)
+    content: truncateToolOutput(failure ? `${formatFailureReceipt(failure)}
+${content}` : content),
+    ...failure ? { metadata: { failure } } : {}
   };
 }
+function visibleToolDefinitions(tools, askMode, contractEnabled) {
+  return tools.definitions().filter(
+    (tool) => (!askMode || tool.category === "read") && (contractEnabled || tool.name !== "task_contract")
+  );
+}
 function truncateToolOutput(content) {
   const max = 8e4;
   return content.length <= max ? content : `${content.slice(0, max)}
@@ -8160,6 +8760,13 @@ function formatToolError(error) {
   if (normalized.name === "ZodError") return `Invalid tool arguments: ${normalized.message}`;
   return normalized.message;
 }
+function classifyThrownToolFailure(error, signal) {
+  const normalized = toError(error);
+  if (isAbortError(normalized) || signal?.aborted) return "cancelled";
+  if (normalized.name === "HookError") return "hook";
+  if (normalized.name === "ZodError" || normalized.name === "ToolInputError") return "schema_input";
+  return "execution";
+}
 function titleFromInput(input2) {
   return input2.trim().replace(/\s+/g, " ").slice(0, 80) || "New session";
 }
@@ -8335,9 +8942,9 @@ function integer(value, fallback, min, max) {
 }
 
 // src/agent/delegation.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 import { join as join17 } from "node:path";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/agent/external-runtime.ts
 async function runExternalAgent(request) {
@@ -8464,86 +9071,86 @@ function numeric(...values) {
 }
 
 // src/agent/team-store.ts
-import { createHash as createHash10, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID13 } from "node:crypto";
 import { lstat as lstat17, readFile as readFile14, readdir as readdir6, rm as rm2 } from "node:fs/promises";
 import { join as join15, resolve as resolve15 } from "node:path";
-import { z as z14 } from "zod";
-var runIdSchema = z14.string().uuid();
-var hashSchema = z14.string().regex(/^[a-f0-9]{64}$/u);
-var artifactSchema = z14.object({
+import { z as z15 } from "zod";
+var runIdSchema = z15.string().uuid();
+var hashSchema = z15.string().regex(/^[a-f0-9]{64}$/u);
+var artifactSchema = z15.object({
   sha256: hashSchema,
-  bytes: z14.number().int().nonnegative().max(5e5)
+  bytes: z15.number().int().nonnegative().max(5e5)
 }).strict();
-var phaseSchema = z14.enum(["work", "review", "revision", "write"]);
-var agentRecordSchema = z14.object({
-  id: z14.string().uuid(),
-  profile: z14.string(),
-  provider: z14.string(),
-  model: z14.string(),
+var phaseSchema = z15.enum(["work", "review", "revision", "write"]);
+var agentRecordSchema = z15.object({
+  id: z15.string().uuid(),
+  profile: z15.string(),
+  provider: z15.string(),
+  model: z15.string(),
   phase: phaseSchema,
-  ok: z14.boolean(),
-  createdAt: z14.string(),
-  startedAt: z14.string().optional(),
-  endedAt: z14.string().optional(),
-  durationMs: z14.number().int().nonnegative().optional(),
-  toolCalls: z14.number().int().nonnegative().optional(),
-  usage: z14.object({
-    inputTokens: z14.number().int().nonnegative(),
-    outputTokens: z14.number().int().nonnegative()
+  ok: z15.boolean(),
+  createdAt: z15.string(),
+  startedAt: z15.string().optional(),
+  endedAt: z15.string().optional(),
+  durationMs: z15.number().int().nonnegative().optional(),
+  toolCalls: z15.number().int().nonnegative().optional(),
+  usage: z15.object({
+    inputTokens: z15.number().int().nonnegative(),
+    outputTokens: z15.number().int().nonnegative()
   }).strict().optional(),
   report: artifactSchema
 }).strict();
-var messageRecordSchema = z14.object({
-  id: z14.string().uuid(),
-  from: z14.string(),
-  to: z14.string(),
-  createdAt: z14.string(),
+var messageRecordSchema = z15.object({
+  id: z15.string().uuid(),
+  from: z15.string(),
+  to: z15.string(),
+  createdAt: z15.string(),
   content: artifactSchema
 }).strict();
-var writerIntegrationSchema = z14.object({
-  status: z14.enum(["ready", "conflict", "integrated"]),
-  checkedAt: z14.string(),
-  detail: z14.string().max(2e4),
-  checkpoint: z14.object({
-    sessionId: z14.string(),
-    checkpointId: z14.string()
+var writerIntegrationSchema = z15.object({
+  status: z15.enum(["ready", "conflict", "integrated"]),
+  checkedAt: z15.string(),
+  detail: z15.string().max(2e4),
+  checkpoint: z15.object({
+    sessionId: z15.string(),
+    checkpointId: z15.string()
   }).strict().optional(),
-  integratedAt: z14.string().optional()
+  integratedAt: z15.string().optional()
 }).strict();
-var writerLaneSchema = z14.object({
-  profile: z14.string(),
-  reviewer: z14.string(),
-  baseCommit: z14.string().regex(/^[a-f0-9]{40,64}$/u),
-  outcome: z14.enum(["accepted", "rejected", "failed", "cancelled"]),
+var writerLaneSchema = z15.object({
+  profile: z15.string(),
+  reviewer: z15.string(),
+  baseCommit: z15.string().regex(/^[a-f0-9]{40,64}$/u),
+  outcome: z15.enum(["accepted", "rejected", "failed", "cancelled"]),
   patch: artifactSchema,
-  files: z14.array(z14.string().min(1).max(4e3)).max(2e3),
-  worktreeCleaned: z14.boolean(),
+  files: z15.array(z15.string().min(1).max(4e3)).max(2e3),
+  worktreeCleaned: z15.boolean(),
   review: artifactSchema.optional(),
   integration: writerIntegrationSchema.optional()
 }).strict();
 var manifestFields = {
   id: runIdSchema,
-  workspace: z14.string(),
-  objective: z14.string().max(3e4),
-  reviewer: z14.string(),
-  createdAt: z14.string(),
-  updatedAt: z14.string(),
-  status: z14.enum(["running", "accepted", "rejected", "failed"]),
-  maxReviewRounds: z14.number().int().min(0).max(3),
-  reviewRounds: z14.number().int().min(0).max(3),
-  agents: z14.array(agentRecordSchema).max(256),
-  messages: z14.array(messageRecordSchema).max(512)
+  workspace: z15.string(),
+  objective: z15.string().max(3e4),
+  reviewer: z15.string(),
+  createdAt: z15.string(),
+  updatedAt: z15.string(),
+  status: z15.enum(["running", "accepted", "rejected", "failed"]),
+  maxReviewRounds: z15.number().int().min(0).max(3),
+  reviewRounds: z15.number().int().min(0).max(3),
+  agents: z15.array(agentRecordSchema).max(256),
+  messages: z15.array(messageRecordSchema).max(512)
 };
-var manifestV1Schema = z14.object({
-  version: z14.literal(1),
+var manifestV1Schema = z15.object({
+  version: z15.literal(1),
   ...manifestFields
 }).strict();
-var manifestV2Schema = z14.object({
-  version: z14.literal(2),
+var manifestV2Schema = z15.object({
+  version: z15.literal(2),
   ...manifestFields,
   writer: writerLaneSchema.optional()
 }).strict();
-var manifestSchema2 = z14.discriminatedUnion("version", [manifestV1Schema, manifestV2Schema]);
+var manifestSchema2 = z15.discriminatedUnion("version", [manifestV1Schema, manifestV2Schema]);
 var TeamRunStore = class {
   workspace;
   directory;
@@ -8558,7 +9165,7 @@ var TeamRunStore = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const manifest = manifestSchema2.parse({
       version: 2,
-      id: randomUUID11(),
+      id: randomUUID13(),
       workspace: this.workspace,
       objective: input2.objective,
       reviewer: input2.reviewer,
@@ -8722,7 +9329,7 @@ var TeamRunStore = class {
   async writeArtifact(runId, content, truncate = true) {
     const data = boundedArtifactText(content, 5e5, truncate);
     const bytes = Buffer.byteLength(data);
-    const sha256 = createHash10("sha256").update(data).digest("hex");
+    const sha256 = createHash11("sha256").update(data).digest("hex");
     const directory = join15(this.runDirectory(runId), "blobs");
     await ensureWorkspaceStorageDirectory(this.workspace, directory, {
       requireActiveNamespace: this.managedDirectory
@@ -8731,7 +9338,7 @@ var TeamRunStore = class {
     try {
       await this.assertRegularFile(path);
       const existing = await readFile14(path);
-      if (createHash10("sha256").update(existing).digest("hex") !== sha256) {
+      if (createHash11("sha256").update(existing).digest("hex") !== sha256) {
         throw new Error(`Team artifact hash collision or corruption: ${sha256}`);
       }
     } catch (error) {
@@ -8752,7 +9359,7 @@ var TeamRunStore = class {
     const path = this.artifactPath(runId, artifact.sha256);
     await this.assertRegularFile(path);
     const data = await readFile14(path);
-    const hash = createHash10("sha256").update(data).digest("hex");
+    const hash = createHash11("sha256").update(data).digest("hex");
     if (hash !== artifact.sha256 || data.byteLength !== artifact.bytes) {
       throw new Error(`Team artifact integrity check failed: ${artifact.sha256}`);
     }
@@ -8815,7 +9422,7 @@ function resolveAgentModelRoute(team, parent, profile) {
 }
 
 // src/agent/writer-lane.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 import { lstat as lstat18, mkdtemp, realpath as realpath7, rm as rm3 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { isAbsolute as isAbsolute5, join as join16, resolve as resolve16 } from "node:path";
@@ -8913,7 +9520,7 @@ var WriterLane = class {
     return {
       baseCommit,
       patch,
-      patchSha256: createHash11("sha256").update(patch).digest("hex"),
+      patchSha256: createHash12("sha256").update(patch).digest("hex"),
       files,
       worktreeCleaned,
       value
@@ -9143,14 +9750,14 @@ async function pathExists2(path) {
 }
 
 // src/agent/delegation.ts
-var writerRunInputSchema = z15.object({
-  task: z15.string().min(1).max(2e4),
-  profile: z15.string().max(64).optional(),
-  reviewer: z15.string().max(64).optional()
+var writerRunInputSchema = z16.object({
+  task: z16.string().min(1).max(2e4),
+  profile: z16.string().max(64).optional(),
+  reviewer: z16.string().max(64).optional()
 }).strict();
-var writerIntegrateInputSchema = z15.object({
-  run_id: z15.string().uuid(),
-  patch_sha256: z15.string().regex(/^[a-f0-9]{64}$/u)
+var writerIntegrateInputSchema = z16.object({
+  run_id: z16.string().uuid(),
+  patch_sha256: z16.string().regex(/^[a-f0-9]{64}$/u)
 }).strict();
 var DelegationManager = class {
   constructor(options) {
@@ -9211,10 +9818,10 @@ var DelegationManager = class {
       },
       async execute(arguments_, context) {
         if (!manager.team.enabled) return { ok: false, content: "Multi-agent delegation is disabled." };
-        const input2 = z15.object({
-          tasks: z15.array(z15.object({
-            profile: z15.string().max(64).optional(),
-            task: z15.string().min(1).max(2e4)
+        const input2 = z16.object({
+          tasks: z16.array(z16.object({
+            profile: z16.string().max(64).optional(),
+            task: z16.string().min(1).max(2e4)
           })).min(1).max(manager.team.maxDelegations)
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
@@ -9260,13 +9867,13 @@ var DelegationManager = class {
       },
       async execute(arguments_, context) {
         if (!manager.team.enabled) return { ok: false, content: "Multi-agent teams are disabled." };
-        const input2 = z15.object({
-          objective: z15.string().min(1).max(3e4),
-          tasks: z15.array(z15.object({
-            profile: z15.string().max(64).optional(),
-            task: z15.string().min(1).max(2e4)
+        const input2 = z16.object({
+          objective: z16.string().min(1).max(3e4),
+          tasks: z16.array(z16.object({
+            profile: z16.string().max(64).optional(),
+            task: z16.string().min(1).max(2e4)
           })).min(1).max(manager.team.maxDelegations),
-          reviewer: z15.string().max(64).optional()
+          reviewer: z16.string().max(64).optional()
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
           profile: task.profile ?? manager.team.defaultProfile,
@@ -9364,7 +9971,7 @@ var DelegationManager = class {
         maxReviewRounds: 0
       });
       await emit?.({ type: "team_start", id: board.id, objective: task });
-      const writerId = randomUUID12();
+      const writerId = randomUUID14();
       await emit?.({ type: "agent_queued", id: writerId, profile: profile.name, task, phase: "write" });
       const draft = await this.writerLane.createDraft(
         Math.min(this.team.maxWriterPatchBytes ?? 6e4, 12e4),
@@ -9734,7 +10341,7 @@ You are the only writer inside a disposable worktree. Make only the bounded requ
     const reviewer = reviewerOverride ?? this.team.reviewerProfile ?? "reviewer";
     const rounds = Math.max(0, this.team.maxReviewRounds ?? 1);
     const board = await this.teamStore?.create({ objective, reviewer, maxReviewRounds: rounds });
-    const runId = board?.id ?? randomUUID12();
+    const runId = board?.id ?? randomUUID14();
     await emit?.({ type: "team_start", id: runId, objective });
     try {
       let results = await this.runBatch(board?.id, tasks, "work", emit, signal);
@@ -9792,7 +10399,7 @@ ${review.summary}`,
     }
   }
   async runBatch(runId, tasks, phase, emit, signal) {
-    const scheduled = tasks.map((task) => ({ id: randomUUID12(), task }));
+    const scheduled = tasks.map((task) => ({ id: randomUUID14(), task }));
     for (const item of scheduled) {
       await emit?.({ type: "agent_queued", id: item.id, profile: item.task.profile, task: item.task.task, phase });
     }
@@ -9901,12 +10508,12 @@ Start the response with exactly VERDICT: ACCEPT when the evidence is sufficient,
     });
   }
   async peerMessage(runId, from, to, content, emit) {
-    const id = randomUUID12();
+    const id = randomUUID14();
     if (runId) await this.teamStore?.recordMessage(runId, { id, from, to, content });
     await emit?.({ type: "agent_message", id, from, to, content });
   }
   async runOne(task, phase, emit, signal, retryOf, scheduledId) {
-    const id = scheduledId ?? randomUUID12();
+    const id = scheduledId ?? randomUUID14();
     const profile = this.options.profiles.get(task.profile);
     const configuredRoute = this.team.routes?.[task.profile];
     const budgetMode = configuredRoute?.budgetMode ?? this.team.budgetMode ?? "observe";
@@ -10818,11 +11425,11 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
 `);
   }
   printText(event) {
-    const { quiet, compact } = this.options;
+    const { quiet, compact: compact2 } = this.options;
     if (quiet) return;
     switch (event.type) {
       case "thinking":
-        if (!compact) process.stderr.write(this.paint.dim(`${this.glyphs.meta} reasoning ${this.glyphs.separator} turn ${event.turn}
+        if (!compact2) process.stderr.write(this.paint.dim(`${this.glyphs.meta} reasoning ${this.glyphs.separator} turn ${event.turn}
 `));
         break;
       case "context":
@@ -10832,7 +11439,7 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
         ));
         break;
       case "prompt":
-        if (!compact) {
+        if (!compact2) {
           process.stderr.write(this.paint.dim(
             `${this.glyphs.meta} prompt ${this.glyphs.separator} ${event.intent} ${this.glyphs.separator} ${event.sections.join(" + ")} ${this.glyphs.separator} ~${event.estimatedTokens} tokens
 `
@@ -10867,12 +11474,21 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
         }
         break;
       case "tasks":
-        if (!compact) {
+        if (!compact2) {
           const completed = event.tasks.filter((task) => task.status === "completed").length;
           process.stderr.write(this.paint.dim(`${this.glyphs.meta} plan ${this.glyphs.separator} ${completed}/${event.tasks.length} complete
 `));
         }
         break;
+      case "contract": {
+        const required = event.contract.acceptanceCriteria.filter((item) => item.required);
+        const satisfied = required.filter((item) => item.status === "satisfied").length;
+        process.stderr.write(this.paint.dim(
+          `${this.glyphs.meta} contract ${this.glyphs.separator} ${event.contract.state} ${this.glyphs.separator} ${satisfied}/${required.length} accepted
+`
+        ));
+        break;
+      }
       case "writer_lane":
         process.stderr.write(
           `${event.status === "ready" || event.status === "integrated" ? this.paint.green(this.glyphs.success) : this.paint.red(this.glyphs.error)} writer ${event.id.slice(0, 8)} ${this.glyphs.separator} ${event.status} ${this.glyphs.separator} ${event.detail}
@@ -10954,6 +11570,7 @@ function sessionSummary(session) {
     createdAt: session.createdAt,
     updatedAt: session.updatedAt,
     tasks: session.tasks,
+    ...session.taskContract ? { taskContract: session.taskContract } : {},
     changedFiles: session.changedFiles,
     ...session.lastRun ? { lastRun: session.lastRun } : {},
     usage: session.usage
@@ -11644,7 +12261,7 @@ function ToolGlyph({ state, glyphs }) {
   if (state === "cancelled") return /* @__PURE__ */ jsx(Text, { color: theme.warning, children: glyphs.warning });
   return /* @__PURE__ */ jsx(Text, { color: theme.error, children: glyphs.error });
 }
-function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = false, expandedToolId, compact = false }) {
+function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = false, expandedToolId, compact: compact2 = false }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
   if (!items.length) {
@@ -11652,13 +12269,13 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
   }
   return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items.map((item, index) => {
     if (item.kind === "user") {
-      return /* @__PURE__ */ jsxs(Box, { marginBottom: compact || item.clipped ? 0 : 1, children: [
+      return /* @__PURE__ */ jsxs(Box, { marginBottom: compact2 || item.clipped ? 0 : 1, children: [
         /* @__PURE__ */ jsx(Box, { width: 2, children: /* @__PURE__ */ jsx(Text, { bold: true, color: theme.accent, children: glyphs.prompt }) }),
         /* @__PURE__ */ jsx(Text, { bold: true, color: theme.textStrong, wrap: "wrap", children: sanitizeTerminalText(item.text) })
       ] }, item.id);
     }
     if (item.kind === "assistant") {
-      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: compact || item.clipped ? 0 : 1, children: [
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: compact2 || item.clipped ? 0 : 1, children: [
         /* @__PURE__ */ jsxs(Text, { bold: true, color: theme.accent, children: [
           glyphs.brand,
           " ",
@@ -11674,7 +12291,7 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
     }
     if (item.kind === "context") {
       const spans = item.spans ?? [];
-      const spanLimit = compact ? 2 : 3;
+      const spanLimit = compact2 ? 2 : 3;
       const innerWidth = Math.max(1, safeWidth(width) - 2);
       return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
         /* @__PURE__ */ jsx(
@@ -11725,7 +12342,7 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
       const duration = item.durationMs !== void 0 ? formatDuration(item.durationMs) : "";
       const detailText = [detail, duration].filter(Boolean).join("  ");
       const expanded = Boolean(item.output) && (showToolOutput || expandedToolId === item.id);
-      const verbose = expanded && item.output ? limitTerminalText(item.output, compact ? 24 : 80) : void 0;
+      const verbose = expanded && item.output ? limitTerminalText(item.output, compact2 ? 24 : 80) : void 0;
       const disclosure = item.output ? expanded ? glyphs.expanded : glyphs.collapsed : "";
       const disclosureWidth = disclosure ? displayWidth(disclosure) + 1 : 0;
       const nameLimit = Math.max(1, Math.min(rowWidth - 2 - disclosureWidth, rowWidth < 64 ? rowWidth - 2 - disclosureWidth : 28));
@@ -11859,7 +12476,7 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
     }
     if (item.kind === "list") return /* @__PURE__ */ jsx(ListPanel, { title: item.title, entries: item.entries, width, glyphMode }, item.id);
     if (item.kind === "context-inspector") {
-      return /* @__PURE__ */ jsx(ContextInspector, { status: item.status, working: item.working, summary: item.summary, width, compact, glyphMode }, item.id);
+      return /* @__PURE__ */ jsx(ContextInspector, { status: item.status, working: item.working, summary: item.summary, width, compact: compact2, glyphMode }, item.id);
     }
     if (item.kind === "theme") return /* @__PURE__ */ jsx(ThemePreview, { name: item.name, width, glyphs }, item.id);
     if (item.kind === "banner") {
@@ -12069,7 +12686,7 @@ function TaskRail({ tasks, width = 80, glyphMode = "auto", maxItems }) {
     ] }) : null
   ] });
 }
-function PermissionCard({ call, category, width = 80, glyphMode = "auto", workspace, compact = false }) {
+function PermissionCard({ call, category, width = 80, glyphMode = "auto", workspace, compact: compact2 = false }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
   const summary = permissionSummary(call);
@@ -12106,7 +12723,7 @@ function PermissionCard({ call, category, width = 80, glyphMode = "auto", worksp
     rowWidth >= 64 ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsx(InlineRow, { parts: shortcuts, width: innerWidth, separator: `  ${glyphs.separator}  `, separatorColor: theme.border }) }) : rowWidth >= 28 ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [
       /* @__PURE__ */ jsx(InlineRow, { parts: shortcuts.slice(0, 2), width: innerWidth, separator: "  ", separatorColor: theme.border }),
       /* @__PURE__ */ jsx(InlineRow, { parts: shortcuts.slice(2), width: innerWidth, separator: "  ", separatorColor: theme.border })
-    ] }) : compact ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [
+    ] }) : compact2 ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [
       /* @__PURE__ */ jsx(InlineRow, { parts: compactNarrowShortcuts.slice(0, 2), width: innerWidth, separator: " ", separatorColor: theme.border }),
       /* @__PURE__ */ jsx(InlineRow, { parts: compactNarrowShortcuts.slice(2), width: innerWidth, separator: " ", separatorColor: theme.border })
     ] }) : /* @__PURE__ */ jsx(Box, { paddingLeft: 2, flexDirection: "column", children: shortcuts.map((part) => part.color ? /* @__PURE__ */ jsx(Text, { color: part.color, children: truncateDisplay(part.text, innerWidth) }, part.text) : /* @__PURE__ */ jsx(Text, { children: truncateDisplay(part.text, innerWidth) }, part.text)) })
@@ -12367,7 +12984,7 @@ function MeterBar({ segments, total, width, glyphs }) {
     remainder ? /* @__PURE__ */ jsx(Text, { color: theme.border, children: glyphs.meterEmpty.repeat(remainder) }) : null
   ] });
 }
-function ContextInspector({ status, working, summary, width, memory, connections, sources: sources2, compact = false, minimal = false, glyphMode = "auto" }) {
+function ContextInspector({ status, working, summary, width, memory, connections, sources: sources2, compact: compact2 = false, minimal = false, glyphMode = "auto" }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
   if (minimal) {
@@ -12387,10 +13004,10 @@ function ContextInspector({ status, working, summary, width, memory, connections
     { label: "summary", detail: summary ? `~${formatTokens(status.summaryTokens)} tokens ${glyphs.separator} ${status.compactedMessages} compacted` : "not created" },
     { label: "long-term", detail: memory ?? `retrieved by relevance ${glyphs.separator} untrusted context` }
   ];
-  if (!compact && working?.constraints.length) entries.push({ label: `constraints ${working.constraints.length}`, detail: working.constraints.slice(0, 2).join(` ${glyphs.separator} `) });
-  if (!compact && working?.decisions.length) entries.push({ label: `decisions ${working.decisions.length}`, detail: working.decisions.slice(0, 2).join(` ${glyphs.separator} `) });
-  if (!compact && working?.openQuestions.length) entries.push({ label: `open ${working.openQuestions.length}`, detail: working.openQuestions.slice(0, 2).join(` ${glyphs.separator} `), tone: "warning" });
-  if (!compact && working?.relevantFiles.length) entries.push({ label: "relevant files", detail: working.relevantFiles.map((file) => compactDisplayPath(sanitizeInlineTerminalText(file), 28)).join(` ${glyphs.separator} `) });
+  if (!compact2 && working?.constraints.length) entries.push({ label: `constraints ${working.constraints.length}`, detail: working.constraints.slice(0, 2).join(` ${glyphs.separator} `) });
+  if (!compact2 && working?.decisions.length) entries.push({ label: `decisions ${working.decisions.length}`, detail: working.decisions.slice(0, 2).join(` ${glyphs.separator} `) });
+  if (!compact2 && working?.openQuestions.length) entries.push({ label: `open ${working.openQuestions.length}`, detail: working.openQuestions.slice(0, 2).join(` ${glyphs.separator} `), tone: "warning" });
+  if (!compact2 && working?.relevantFiles.length) entries.push({ label: "relevant files", detail: working.relevantFiles.map((file) => compactDisplayPath(sanitizeInlineTerminalText(file), 28)).join(` ${glyphs.separator} `) });
   if (sources2?.length) {
     const pinned = sources2.filter((source) => source.state === "pinned");
     const muted = sources2.filter((source) => source.state === "muted");
@@ -12511,8 +13128,8 @@ function Banner({ model, engine, workspace, version, width, glyphs }) {
 function UpdateNotice({ current, latest, command: command2, highlights, width, glyphs }) {
   const theme = useTheme();
   const availableWidth = safeWidth(width);
-  const compact = availableWidth < 48;
-  const parts = compact ? [
+  const compact2 = availableWidth < 48;
+  const parts = compact2 ? [
     { text: `${glyphs.up} `, color: theme.accent, bold: true },
     { text: `v${current}`, color: theme.dim, bold: false },
     { text: ` ${glyphs.arrow} `, color: theme.muted, bold: false },
@@ -12533,7 +13150,7 @@ function UpdateNotice({ current, latest, command: command2, highlights, width, g
   const bullets = bulletWidth > 0 ? (highlights ?? []).map((line) => truncateDisplay(sanitizeInlineTerminalText(line), bulletWidth)) : [];
   return /* @__PURE__ */ jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [
     /* @__PURE__ */ jsx(Box, { children: truncated ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: rendered }) : parts.map((part, index) => /* @__PURE__ */ jsx(Text, { color: part.color, bold: part.bold, children: part.text }, index)) }),
-    compact ? /* @__PURE__ */ jsx(Text, { color: theme.dim, children: truncateDisplay(`  run ${command2}`, availableWidth) }) : null,
+    compact2 ? /* @__PURE__ */ jsx(Text, { color: theme.dim, children: truncateDisplay(`  run ${command2}`, availableWidth) }) : null,
     bullets.map((line, index) => /* @__PURE__ */ jsx(Text, { color: theme.dim, children: `${bulletPrefix}${line}` }, index))
   ] });
 }
@@ -13441,9 +14058,9 @@ function tailText(value, width, maxRows) {
   return `${marker}
 ${selected.join("\n")}`;
 }
-function estimateTimelineItemRows(item, { width, compact = false, showToolOutput = false, expandedToolId }) {
+function estimateTimelineItemRows(item, { width, compact: compact2 = false, showToolOutput = false, expandedToolId }) {
   const rowWidth = Math.max(1, Math.floor(width));
-  const gap = compact ? 0 : 1;
+  const gap = compact2 ? 0 : 1;
   if (item.kind === "user") return wrappedRows(item.text, Math.max(1, rowWidth - 2)) + (item.clipped ? 0 : gap);
   if (item.kind === "assistant") {
     return 1 + richTextRows(item.text, Math.max(1, rowWidth - 2)) + (item.clipped ? 0 : gap);
@@ -13455,7 +14072,7 @@ function estimateTimelineItemRows(item, { width, compact = false, showToolOutput
     const detail = item.errorDetail || item.detail;
     const detailRows = narrow && detail ? 1 : 0;
     const metaRows = item.meta ? 1 : 0;
-    const outputRows = (showToolOutput || item.id === expandedToolId) && item.output ? Math.min(compact ? 25 : 81, richTextRows(item.output, Math.max(1, rowWidth - 2))) : 0;
+    const outputRows = (showToolOutput || item.id === expandedToolId) && item.output ? Math.min(compact2 ? 25 : 81, richTextRows(item.output, Math.max(1, rowWidth - 2))) : 0;
     return 1 + detailRows + metaRows + outputRows;
   }
   if (item.kind === "list") {
@@ -13469,7 +14086,7 @@ function estimateTimelineItemRows(item, { width, compact = false, showToolOutput
   if (item.kind === "theme") return 3;
   if (item.kind === "context") {
     const metaRows = rowWidth < 64 ? 2 : 1;
-    const spanLimit = compact ? 2 : 3;
+    const spanLimit = compact2 ? 2 : 3;
     const spanCount = Math.min(item.spans?.length ?? 0, spanLimit);
     const moreRow = (item.spans?.length ?? 0) > spanLimit ? 1 : 0;
     const degradationRows = item.degradation ? metaRows : 0;
@@ -13567,6 +14184,21 @@ function finalizeAssistant(items, id, content) {
 function endStreamingAssistants(items) {
   return items.map((item) => item.kind === "assistant" && item.streaming ? { ...item, streaming: false } : item);
 }
+function updateContractProgress(items, contract, separator = " | ") {
+  const id = "task-contract-progress";
+  if (contract.state === "satisfied") return items.filter((item) => item.id !== id);
+  const required = contract.acceptanceCriteria.filter((item) => item.required);
+  const satisfied = required.filter((item) => item.status === "satisfied").length;
+  const next = {
+    id,
+    kind: "notice",
+    tone: contract.state === "blocked" ? "error" : "info",
+    text: `Contract ${contract.state}${separator}${satisfied}/${required.length} accepted`
+  };
+  const index = items.findIndex((item) => item.id === id);
+  if (index < 0) return [...items, next].slice(-500);
+  return items.map((item, itemIndex) => itemIndex === index ? next : item);
+}
 function updateAgent(items, event) {
   const found = items.some((item) => item.kind === "agent" && item.id === event.id);
   if (!found) {
@@ -13659,7 +14291,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   const colorEnabled = config.ui.color && !process.env.NO_COLOR;
   const [theme, setTheme] = useState2(() => resolveThemeWithColor(config.ui.theme, colorEnabled));
   const [themeCatalogRevision, setThemeCatalogRevision] = useState2(0);
-  const [compact, setCompact] = useState2(config.ui.compact);
+  const [compact2, setCompact] = useState2(config.ui.compact);
   const [interactionMode, setInteractionMode] = useState2(planMode ? "plan" : askMode ? "ask" : "build");
   const [input2, setInput] = useState2("");
   const [busy, setBusy] = useState2(false);
@@ -13859,6 +14491,11 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
       case "tasks":
         setTasks(event.tasks.map((task) => ({ ...task })));
         break;
+      case "contract": {
+        setTimeline((items) => updateContractProgress(items, event.contract, separator));
+        refreshSession();
+        break;
+      }
       case "skill":
         append({ id: nextId(), kind: "skill", name: event.name, description: event.description });
         break;
@@ -14351,7 +14988,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
     }
     if (command2 === "density") {
       const normalized = argument.toLocaleLowerCase();
-      const next = normalized === "compact" ? true : normalized === "comfortable" || normalized === "normal" ? false : normalized === "" || normalized === "toggle" ? !compact : void 0;
+      const next = normalized === "compact" ? true : normalized === "comfortable" || normalized === "normal" ? false : normalized === "" || normalized === "toggle" ? !compact2 : void 0;
       if (next === void 0) throw new Error("Usage: /density [compact|comfortable]");
       setCompact(next);
       await saveUiPreference({ compact: next });
@@ -14444,7 +15081,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
       })));
       return true;
     }
-  }, [append, appendList, compact, config, ellipsis, exit, extensions, interactionMode, refreshSession, requestPermission, runner, separator, showToolOutput, tasks, theme, workflows]);
+  }, [append, appendList, compact2, config, ellipsis, exit, extensions, interactionMode, refreshSession, requestPermission, runner, separator, showToolOutput, tasks, theme, workflows]);
   const submit = useCallback(async (raw, mode = "normal") => {
     const trimmed = raw.trim();
     if (!trimmed) return;
@@ -14808,7 +15445,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   const tokenTotal = session.usage.inputTokens + session.usage.outputTokens;
   const contextStatus = runner.getContextStatus();
   const frame = spinnerFrames()[frameIndex % spinnerFrames().length];
-  const compactUi = compact || terminalHeight < 28;
+  const compactUi = compact2 || terminalHeight < 28;
   const constrainedHeight = terminalHeight < 18;
   const compactComposer = terminalHeight < 18;
   const minimalInspector = terminalHeight < 22;
@@ -15014,6 +15651,16 @@ function initialTimeline(session, banner, setupProblem) {
   if (!items.length) {
     items.push({ id: nextId(), kind: "banner", model: banner.model, engine: banner.engine, workspace: banner.workspace, version: banner.version });
   }
+  if (session.taskContract && session.taskContract.state !== "satisfied") {
+    const required = session.taskContract.acceptanceCriteria.filter((item) => item.required);
+    const satisfied = required.filter((item) => item.status === "satisfied").length;
+    items.push({
+      id: "task-contract-progress",
+      kind: "notice",
+      tone: session.taskContract.state === "blocked" ? "error" : "info",
+      text: `Contract ${session.taskContract.state} | ${satisfied}/${required.length} accepted`
+    });
+  }
   if (setupProblem && items.length <= 1) items.push({ id: nextId(), kind: "notice", tone: "error", text: setupProblem });
   return items;
 }
@@ -15105,17 +15752,17 @@ function composerAttachments(value) {
   const paths = [...value.matchAll(/(?:^|\s)@([^\s]+)/g)].map((match) => match[1]).filter((path) => Boolean(path));
   return [...new Set(paths)].slice(-3);
 }
-function permissionRows(width, hasCwd, compact) {
+function permissionRows(width, hasCwd, compact2) {
   const content = 3 + (hasCwd ? 1 : 0);
   if (width >= 64) return content + 2;
   if (width >= 28) return content + 3;
-  if (compact) return content + 3;
+  if (compact2) return content + 3;
   return content + 5;
 }
-function contextInspectorRows(session, compact, width, minimal) {
+function contextInspectorRows(session, compact2, width, minimal) {
   if (minimal) return 2;
   const working = session.workingMemory;
-  const entries = 5 + (compact ? 0 : (working?.constraints.length ? 1 : 0) + (working?.decisions.length ? 1 : 0) + (working?.openQuestions.length ? 1 : 0) + (working?.relevantFiles.length ? 1 : 0));
+  const entries = 5 + (compact2 ? 0 : (working?.constraints.length ? 1 : 0) + (working?.decisions.length ? 1 : 0) + (working?.openQuestions.length ? 1 : 0) + (working?.relevantFiles.length ? 1 : 0));
   return 2 + entries * (width < 52 ? 2 : 1);
 }
 function contextInspectorStatus(status) {
@@ -15167,14 +15814,14 @@ function WorkspacePreparationView({
   const theme = useTheme();
   const safeWidth2 = Math.max(1, Math.floor(width));
   const innerWidth = Math.max(1, safeWidth2 - (safeWidth2 >= 24 ? 4 : 0));
-  const compact = safeWidth2 < 48;
+  const compact2 = safeWidth2 < 48;
   const constrained = height < 14;
   const ascii = process.env.SKEIN_GLYPHS === "ascii" || process.env.MOSAIC_GLYPHS === "ascii";
   const spinner = (ascii ? [".", "o", "O", "o"] : ["\u25DC", "\u25E0", "\u25DD", "\u25DE", "\u25E1", "\u25DF"])[frame % (ascii ? 4 : 6)];
   const separator = ascii ? "|" : "\xB7";
   const brand = ascii ? "*" : PRODUCT_MARK;
   const phase = readiness ? "ready" : error ? "error" : progress.phase;
-  const phaseLabel = preparationLabel(phase, progress, readiness, compact);
+  const phaseLabel = preparationLabel(phase, progress, readiness, compact2);
   const detail = preparationDetail(phase, progress, readiness, error);
   const modelLine = `model ${sanitizeTerminalText(model)}`;
   const workspaceLine = `workspace ${compactDisplayPath(sanitizeTerminalText(workspace), Math.max(1, innerWidth - 10))}`;
@@ -15186,14 +15833,14 @@ function WorkspacePreparationView({
         "  ",
         PRODUCT_NAME.toUpperCase()
       ] }),
-      !compact && !constrained ? /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
+      !compact2 && !constrained ? /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
         "  ",
         separator,
         "  LOCAL CONTEXT"
       ] }) : null
     ] }),
     !constrained ? /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: truncateDisplay("Ground the workspace before the first request.", innerWidth) }) : null,
-    !constrained && !compact ? /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(`${modelLine}  ${separator}  ${workspaceLine}`, innerWidth) }) : !constrained ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+    !constrained && !compact2 ? /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(`${modelLine}  ${separator}  ${workspaceLine}`, innerWidth) }) : !constrained ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
       /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(modelLine, innerWidth) }),
       /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(workspaceLine, innerWidth) })
     ] }) : /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(workspaceLine, innerWidth) }),
@@ -15207,10 +15854,10 @@ function WorkspacePreparationView({
         step2.glyph,
         " "
       ] }),
-      /* @__PURE__ */ jsx4(Text4, { bold: step2.state === "active", color: step2.state === "pending" ? theme.dim : theme.textStrong, children: truncateDisplay(step2.label, compact ? 8 : 10) }),
+      /* @__PURE__ */ jsx4(Text4, { bold: step2.state === "active", color: step2.state === "pending" ? theme.dim : theme.textStrong, children: truncateDisplay(step2.label, compact2 ? 8 : 10) }),
       /* @__PURE__ */ jsxs4(Text4, { color: step2.state === "active" ? theme.muted : theme.dim, children: [
         "  ",
-        truncateDisplay(step2.detail, Math.max(1, innerWidth - displayWidth(step2.glyph) - (compact ? 12 : 14)))
+        truncateDisplay(step2.detail, Math.max(1, innerWidth - displayWidth(step2.glyph) - (compact2 ? 12 : 14)))
       ] })
     ] }, step2.id)) }),
     /* @__PURE__ */ jsxs4(Box3, { marginTop: 1, children: [
@@ -15351,9 +15998,9 @@ async function runWorkspacePreparation(engine, config, options = {}) {
   await instance.waitUntilExit();
   return result ?? { status: "cancelled" };
 }
-function preparationLabel(phase, progress, readiness, compact = false) {
+function preparationLabel(phase, progress, readiness, compact2 = false) {
   if (phase === "ready") {
-    if (compact) return "Index verified";
+    if (compact2) return "Index verified";
     return readiness?.rebuilt ? "Workspace index created and verified" : "Workspace index verified";
   }
   if (phase === "error") return "Workspace preparation failed";
@@ -15757,7 +16404,7 @@ function OnboardingFlow({ initialConfig, saveConfig, onFinish }) {
   }, [finish, saveConfig, state]);
   return /* @__PURE__ */ jsx5(OnboardingScreen, { state, dispatch, width, compact: compactHeight });
 }
-function OnboardingScreen({ state, dispatch, width, compact = false }) {
+function OnboardingScreen({ state, dispatch, width, compact: compact2 = false }) {
   const theme = useTheme();
   const ascii = process.env.SKEIN_GLYPHS === "ascii" || process.env.MOSAIC_GLYPHS === "ascii";
   const marker = ascii ? ">" : "\u203A";
@@ -15774,14 +16421,14 @@ function OnboardingScreen({ state, dispatch, width, compact = false }) {
     ] }),
     /* @__PURE__ */ jsx5(Text6, { color: theme.border, children: truncateDisplay(stageDivider(ascii, headerWidth), headerWidth) }),
     /* @__PURE__ */ jsx5(Text6, { color: theme.dim, children: truncateDisplay(stage.name, headerWidth) }),
-    !compact ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
     /* @__PURE__ */ jsx5(Text6, { color: theme.textStrong, bold: true, children: truncateDisplay(titleForStep(state.step), headerWidth) }),
-    !compact ? /* @__PURE__ */ jsx5(Text6, { color: theme.muted, wrap: "wrap", children: descriptionForStep(state) }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Text6, { color: theme.muted, wrap: "wrap", children: descriptionForStep(state) }) : null,
     summary ? /* @__PURE__ */ jsx5(Text6, { color: theme.dim, children: truncateDisplay(summary, headerWidth) }) : null,
-    !compact ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
-    state.step === "method" ? /* @__PURE__ */ jsx5(OptionList, { options: methods, selected: state.selected, marker, width: headerWidth, compact }) : null,
-    state.step === "official-provider" ? /* @__PURE__ */ jsx5(OptionList, { options: officialProviders, selected: state.selected, marker, width: headerWidth, compact }) : null,
-    state.step === "relay-protocol" ? /* @__PURE__ */ jsx5(OptionList, { options: relayProtocols, selected: state.selected, marker, width: headerWidth, compact }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
+    state.step === "method" ? /* @__PURE__ */ jsx5(OptionList, { options: methods, selected: state.selected, marker, width: headerWidth, compact: compact2 }) : null,
+    state.step === "official-provider" ? /* @__PURE__ */ jsx5(OptionList, { options: officialProviders, selected: state.selected, marker, width: headerWidth, compact: compact2 }) : null,
+    state.step === "relay-protocol" ? /* @__PURE__ */ jsx5(OptionList, { options: relayProtocols, selected: state.selected, marker, width: headerWidth, compact: compact2 }) : null,
     inputField ? /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs5(Box4, { children: [
         /* @__PURE__ */ jsx5(Text6, { color: theme.textStrong, bold: true, children: inputField.label }),
@@ -15809,18 +16456,18 @@ function OnboardingScreen({ state, dispatch, width, compact = false }) {
       "! ",
       truncateDisplay(state.error, Math.max(1, headerWidth - 2))
     ] }) : null,
-    !compact ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
     /* @__PURE__ */ jsx5(Text6, { color: theme.dim, children: footerForStep(state, headerWidth) })
   ] });
 }
-function OptionList({ options, selected, marker, width, compact }) {
+function OptionList({ options, selected, marker, width, compact: compact2 }) {
   const theme = useTheme();
   return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", children: options.map((option, index) => {
     const active = index === selected;
     const prefix = active ? `${marker} ` : "  ";
     const available = Math.max(1, width - displayWidth(prefix) - (active ? 2 : 0));
     const label = `${prefix}${truncateDisplay(option.label, available)}`;
-    return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: compact || index === options.length - 1 ? 0 : 1, children: [
+    return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: compact2 || index === options.length - 1 ? 0 : 1, children: [
       /* @__PURE__ */ jsx5(
         Text6,
         {
@@ -15830,7 +16477,7 @@ function OptionList({ options, selected, marker, width, compact }) {
           children: active ? padDisplay(label, width) : label
         }
       ),
-      !compact && width >= 36 || active ? /* @__PURE__ */ jsx5(Box4, { marginLeft: 2, width: Math.max(1, width - 2), children: /* @__PURE__ */ jsx5(Text6, { color: active ? theme.muted : theme.dim, wrap: "wrap", children: option.detail }) }) : null
+      !compact2 && width >= 36 || active ? /* @__PURE__ */ jsx5(Box4, { marginLeft: 2, width: Math.max(1, width - 2), children: /* @__PURE__ */ jsx5(Text6, { color: active ? theme.muted : theme.dim, wrap: "wrap", children: option.detail }) }) : null
     ] }, option.label);
   }) });
 }
@@ -15953,7 +16600,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import stripAnsi4 from "strip-ansi";
 
 // src/mcp/tool.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import stripAnsi3 from "strip-ansi";
 var MAX_ARGUMENT_BYTES = 256e3;
 var MAX_DESCRIPTION_LENGTH = 4e3;
@@ -15961,7 +16608,7 @@ var MAX_RESULT_LENGTH = 8e4;
 var MAX_SCHEMA_BYTES = 1e5;
 function createMcpToolAdapter(options) {
   const { remoteTool } = options;
-  const inputSchema10 = copyInputSchema(remoteTool.inputSchema);
+  const inputSchema11 = copyInputSchema(remoteTool.inputSchema);
   return {
     definition: {
       name: options.exposedName,
@@ -15969,7 +16616,7 @@ function createMcpToolAdapter(options) {
       // MCP servers are an external trust boundary. Read-only annotations are
       // hints from that server and must not lower the local permission level.
       category: "network",
-      inputSchema: inputSchema10
+      inputSchema: inputSchema11
     },
     permissionCategories: () => ["network"],
     async execute(arguments_, context) {
@@ -16106,7 +16753,7 @@ function fitToolName(name, identity) {
   return `${name.slice(0, 64 - suffix.length).replace(/_+$/g, "")}${suffix}`;
 }
 function shortHash(value) {
-  return createHash12("sha256").update(value).digest("hex").slice(0, 8);
+  return createHash13("sha256").update(value).digest("hex").slice(0, 8);
 }
 function truncateResult(content) {
   if (content.length <= MAX_RESULT_LENGTH) return content;
@@ -16729,9 +17376,9 @@ async function closeTransportQuietly(transport) {
 }
 
 // src/memory/tools.ts
-import { z as z16 } from "zod";
-var scopeSchema = z16.enum(["user", "workspace", "session", "agent"]);
-var kindSchema = z16.enum(["semantic", "episodic", "procedural"]);
+import { z as z17 } from "zod";
+var scopeSchema = z17.enum(["user", "workspace", "session", "agent"]);
+var kindSchema = z17.enum(["semantic", "episodic", "procedural"]);
 function createMemoryTools(store) {
   return [
     {
@@ -16746,10 +17393,10 @@ function createMemoryTools(store) {
         }, ["query"])
       },
       async execute(arguments_, context) {
-        const input2 = z16.object({
-          query: z16.string().max(4e3),
+        const input2 = z17.object({
+          query: z17.string().max(4e3),
           scope: scopeSchema.optional(),
-          limit: z16.number().int().min(1).max(20).optional()
+          limit: z17.number().int().min(1).max(20).optional()
         }).parse(arguments_);
         const scopes = input2.scope ? [{ scope: input2.scope, scopeKey: scopeKey(input2.scope, context) }] : availableScopes(context);
         const records = store.search(input2.query, { scopes, limit: input2.limit ?? 8 });
@@ -16781,17 +17428,17 @@ ${record.content}`
         }, ["content", "rationale"])
       },
       async execute(arguments_, context) {
-        const input2 = z16.object({
-          content: z16.string().min(1).max(12e3),
-          rationale: z16.string().min(1).max(1e3),
+        const input2 = z17.object({
+          content: z17.string().min(1).max(12e3),
+          rationale: z17.string().min(1).max(1e3),
           scope: scopeSchema.optional(),
           kind: kindSchema.optional(),
-          tags: z16.array(z16.string()).max(24).optional(),
-          importance: z16.number().min(0).max(1).optional(),
-          confidence: z16.number().min(0).max(1).optional(),
-          agent: z16.string().max(64).optional(),
-          revision: z16.string().max(240).optional(),
-          conflictKey: z16.string().max(240).optional()
+          tags: z17.array(z17.string()).max(24).optional(),
+          importance: z17.number().min(0).max(1).optional(),
+          confidence: z17.number().min(0).max(1).optional(),
+          agent: z17.string().max(64).optional(),
+          revision: z17.string().max(240).optional(),
+          conflictKey: z17.string().max(240).optional()
         }).strict().parse(arguments_);
         const scope = input2.scope ?? "workspace";
         const candidate = store.propose({
@@ -16829,9 +17476,9 @@ ${record.content}`
         }, ["id"])
       },
       async execute(arguments_) {
-        const input2 = z16.object({
-          id: z16.string().uuid(),
-          permanent: z16.boolean().optional()
+        const input2 = z17.object({
+          id: z17.string().uuid(),
+          permanent: z17.boolean().optional()
         }).parse(arguments_);
         const changed = input2.permanent ? store.remove(input2.id) : store.archive(input2.id);
         return {
@@ -17035,7 +17682,7 @@ function escapeAttribute6(value) {
 }
 
 // src/workflows/catalog.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var builtInWorkflows = [
   {
     name: "implement",
@@ -17126,7 +17773,7 @@ function createWorkflowTool(catalog) {
       }, ["name", "task"])
     },
     async execute(arguments_) {
-      const input2 = z17.object({ name: z17.string(), task: z17.string().min(1).max(2e4) }).parse(arguments_);
+      const input2 = z18.object({ name: z18.string(), task: z18.string().min(1).max(2e4) }).parse(arguments_);
       const workflow = catalog.get(input2.name);
       if (!workflow) return { ok: false, content: `Unknown workflow: ${input2.name}` };
       return {