@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/index-h0mqx2ed.js

@@ -0,0 +1,1373 @@
+import {
+  MODEL_BUDGET_KEY,
+  TERMINAL_SESSION_RUN_STATUSES,
+  USAGE_LEDGER_KEY,
+  estimateRequestTokens,
+  harnessToolExecution,
+  inspectRuntimeDiagnostics,
+  inspectRuntimeManifest,
+  inspectUsageLedger,
+  protectStateFromGit,
+  taskSources,
+  validateStateDirectory,
+  verifierSchema
+} from "./index-42gp2hy8.js";
+import {
+  harnessExecutionSession,
+  withWorkspaceMutation
+} from "./index-z0qxmkm2.js";
+import {
+  SqliteDatabase,
+  createEditProposal,
+  fileDigestSchema,
+  readRegularFileNoFollow,
+  statRegularFileNoFollow,
+  workspaceFilePathSchema
+} from "./index-yb239ghk.js";
+import {
+  HarnessStateConflictError,
+  HarnessWorkspaceError,
+  defaultHarnessNamespace
+} from "./index-gq9xagx2.js";
+
+// src/persistence/workspace-checkpoints.ts
+import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
+import { z } from "zod";
+var fileSchema = z.strictObject({
+  path: workspaceFilePathSchema,
+  digest: fileDigestSchema,
+  content: z.string().max(65536),
+  mode: z.number().int().min(0).max(511)
+}).refine((file) => Buffer.byteLength(file.content) <= 65536 && !file.content.includes("\x00") && file.digest === `sha256:${createHash("sha256").update(file.content).digest("hex")}`, "Invalid checkpoint content identity.");
+var workspaceCheckpointSchema = z.strictObject({
+  id: z.string().uuid(),
+  sessionId: z.string(),
+  turnId: z.string(),
+  files: z.array(fileSchema).min(1).max(20)
+});
+var workspaceRestoreOperationSchema = z.strictObject({
+  id: z.string().uuid(),
+  checkpoint: workspaceCheckpointSchema,
+  proposalId: fileDigestSchema,
+  expected: z.record(z.string(), fileDigestSchema),
+  stage: z.enum(["prepared", "forking", "forked", "applying", "applied", "completed"]),
+  forkSessionId: z.string().optional()
+});
+var digest = (content) => `sha256:${createHash("sha256").update(content).digest("hex")}`;
+var retentionSelection = z.object({ checkpointIds: z.array(z.string().uuid()).max(100), completedRestoreIds: z.array(z.string().uuid()).max(100) }).strict().refine((value) => value.checkpointIds.length + value.completedRestoreIds.length > 0 && new Set([...value.checkpointIds, ...value.completedRestoreIds]).size === value.checkpointIds.length + value.completedRestoreIds.length, "Select unique checkpoint and completed restore IDs.");
+var openWorkspaceCheckpointStore = async (workspace, sessions) => {
+  const key = createHash("sha256").update("workspace\x00").update(workspace.root).digest("hex");
+  if (key !== sessions.workspaceKey)
+    throw new Error("Checkpoint session store belongs to a different workspace.");
+  const before = await statRegularFileNoFollow(sessions.databasePath, { label: "Checkpoint database", requireSingleLink: true });
+  if (before.uid !== process.getuid?.() || before.mode & 63)
+    throw new Error("Checkpoint database must be private.");
+  const db = new SqliteDatabase(sessions.databasePath, { create: false });
+  const after = await statRegularFileNoFollow(sessions.databasePath, { label: "Checkpoint database", requireSingleLink: true });
+  if (before.dev !== after.dev || before.ino !== after.ino) {
+    db.close();
+    throw new Error("Checkpoint database changed.");
+  }
+  db.exec("CREATE TABLE IF NOT EXISTS zhivex_workspace_checkpoints (id TEXT PRIMARY KEY, workspace_key TEXT NOT NULL, scope_key TEXT NOT NULL, kind TEXT NOT NULL, body TEXT NOT NULL)");
+  const save = (kind, value) => {
+    const existing = db.query("SELECT id FROM zhivex_workspace_checkpoints WHERE id=?").get(value.id);
+    const count = db.query("SELECT COUNT(*) AS count FROM zhivex_workspace_checkpoints WHERE workspace_key=? AND scope_key=?").get(sessions.workspaceKey, sessions.scopeKey)?.count ?? 0;
+    if (!existing && count >= 100)
+      throw new Error("Checkpoint scope storage limit reached (100 records).");
+    const body = JSON.stringify(value);
+    if (Buffer.byteLength(body) > 2 * 1024 * 1024)
+      throw new Error("Checkpoint exceeds storage limit.");
+    db.query("INSERT INTO zhivex_workspace_checkpoints(id, workspace_key, scope_key, kind, body) VALUES (?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET body=excluded.body WHERE workspace_key=excluded.workspace_key AND scope_key=excluded.scope_key AND kind=excluded.kind").run(value.id, sessions.workspaceKey, sessions.scopeKey, kind, body);
+  };
+  const load = (kind, id) => {
+    const row = db.query("SELECT body FROM zhivex_workspace_checkpoints WHERE id=? AND workspace_key=? AND scope_key=? AND kind=?").get(id, sessions.workspaceKey, sessions.scopeKey, kind);
+    if (!row)
+      throw new Error("Unknown checkpoint or restore operation in this scope.");
+    return JSON.parse(row.body);
+  };
+  const read = async (target) => {
+    const authorized = await workspace.readFile(target, 1, 1);
+    const { contents, stat } = await readRegularFileNoFollow(path.join(workspace.root, target), {
+      label: "Checkpoint target",
+      maxBytes: 65536,
+      requireSingleLink: true
+    });
+    const content = new TextDecoder("utf-8", { fatal: true }).decode(contents);
+    if (contents.includes(0) || digest(contents) !== authorized.digest)
+      throw new Error("Checkpoint file changed while reading.");
+    return fileSchema.parse({ path: target, digest: digest(contents), content, mode: stat.mode & 511 });
+  };
+  const validateTurn = async (checkpoint) => {
+    const session = await sessions.get(checkpoint.sessionId);
+    const run = session?.runs.find((entry) => entry.turnId === checkpoint.turnId);
+    if (!session || !run || !TERMINAL_SESSION_RUN_STATUSES.includes(run.status)) {
+      throw new Error("Checkpoint requires an existing terminal conversation turn.");
+    }
+    return session;
+  };
+  const proposal = (operation) => {
+    if (new Set(operation.checkpoint.files.map((file) => file.path)).size !== operation.checkpoint.files.length || operation.checkpoint.files.some((file) => digest(file.content) !== file.digest))
+      throw new Error("Checkpoint content identity is corrupt.");
+    const changes = operation.checkpoint.files.map((file) => ({ path: file.path, expectedDigest: operation.expected[file.path], content: file.content }));
+    const result = createEditProposal({ changes });
+    if (result.proposalId !== operation.proposalId)
+      throw new Error("Restore proposal identity is corrupt.");
+    return { proposalId: result.proposalId, changes };
+  };
+  const getOperation = (id) => workspaceRestoreOperationSchema.parse(load("restore", id));
+  const list = (kind) => db.query("SELECT body FROM zhivex_workspace_checkpoints WHERE workspace_key=? AND scope_key=? AND kind=? ORDER BY id").all(sessions.workspaceKey, sessions.scopeKey, kind).map((row) => JSON.parse(row.body));
+  const summary = (checkpoint) => ({
+    id: checkpoint.id,
+    sessionId: checkpoint.sessionId,
+    turnId: checkpoint.turnId,
+    files: checkpoint.files.map((file) => ({
+      path: file.path,
+      digest: file.digest,
+      bytes: Buffer.byteLength(file.content),
+      mode: file.mode
+    }))
+  });
+  const inventory = () => db.query("SELECT id,kind,body FROM zhivex_workspace_checkpoints WHERE workspace_key=? AND scope_key=? ORDER BY id").all(sessions.workspaceKey, sessions.scopeKey).map((row) => {
+    const value = row.kind === "checkpoint" ? workspaceCheckpointSchema.parse(JSON.parse(row.body)) : row.kind === "restore" ? workspaceRestoreOperationSchema.parse(JSON.parse(row.body)) : undefined;
+    if (!value || value.id !== row.id)
+      throw new Error("Invalid checkpoint inventory.");
+    return { ...row, value };
+  });
+  const retentionPlan = (input) => {
+    const selection = retentionSelection.parse(input);
+    const rows = inventory();
+    const selected = new Set([...selection.checkpointIds, ...selection.completedRestoreIds]);
+    for (const id of selection.checkpointIds) {
+      if (!rows.some((row) => row.id === id && row.kind === "checkpoint"))
+        throw new Error("Unknown checkpoint selection in this scope.");
+    }
+    for (const id of selection.completedRestoreIds) {
+      const row = rows.find((row2) => row2.id === id && row2.kind === "restore");
+      if (!row || !("stage" in row.value) || row.value.stage !== "completed")
+        throw new Error("Retention cannot remove pending or unknown restore evidence.");
+    }
+    for (const row of rows) {
+      if ("checkpoint" in row.value && selection.checkpointIds.includes(row.value.checkpoint.id) && !selected.has(row.id)) {
+        throw new Error("Checkpoint is still referenced by a retained restore operation.");
+      }
+    }
+    const records = rows.filter((row) => selected.has(row.id)).map((row) => ({
+      id: row.id,
+      kind: row.kind,
+      sessionId: "checkpoint" in row.value ? row.value.checkpoint.sessionId : row.value.sessionId,
+      bytes: Buffer.byteLength(row.body)
+    }));
+    const planId = digest(JSON.stringify({
+      workspace: sessions.workspaceKey,
+      scope: sessions.scopeKey,
+      selection: [...selected].sort(),
+      inventory: rows.map((row) => [row.id, row.kind, digest(row.body)])
+    }));
+    return {
+      planId,
+      selection: { checkpointIds: [...selection.checkpointIds].sort(), completedRestoreIds: [...selection.completedRestoreIds].sort() },
+      records,
+      recordsBefore: rows.length,
+      recordsAfter: rows.length - records.length,
+      bytesRemoved: records.reduce((sum, row) => sum + row.bytes, 0),
+      workspaceFilesChanged: false,
+      conversationsChanged: false
+    };
+  };
+  return {
+    close: () => db.close(),
+    getCheckpoint: (id) => workspaceCheckpointSchema.parse(load("checkpoint", id)),
+    getOperation,
+    storageStatus: () => {
+      const rows = inventory();
+      const operations = rows.filter((row) => ("stage" in row.value));
+      const referenced = new Set(operations.map((row) => row.value.checkpoint.id));
+      return {
+        policy: "explicit-reviewed-removal",
+        automaticEviction: false,
+        maxRecords: 100,
+        maxRecordBytes: 2 * 1024 * 1024,
+        maxFilesPerCheckpoint: 20,
+        maxFileBytes: 65536,
+        records: rows.length,
+        availableRecords: Math.max(0, 100 - rows.length),
+        serializedBytes: rows.reduce((sum, row) => sum + Buffer.byteLength(row.body), 0),
+        pendingRestores: operations.filter((row) => row.value.stage !== "completed").length,
+        checkpoints: rows.filter((row) => row.kind === "checkpoint").map((row) => ({ id: row.id, referenced: referenced.has(row.id) }))
+      };
+    },
+    prepareRetention: retentionPlan,
+    applyRetention: async (selection, reviewedPlanId) => withWorkspaceMutation(workspace.root, async () => {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const plan = retentionPlan(selection);
+        if (plan.planId !== reviewedPlanId)
+          throw new Error("Retention inventory changed or was not reviewed.");
+        for (const row of plan.records)
+          db.query("DELETE FROM zhivex_workspace_checkpoints WHERE id=? AND workspace_key=? AND scope_key=? AND kind=?").run(row.id, sessions.workspaceKey, sessions.scopeKey, row.kind);
+        db.exec("COMMIT");
+        return plan;
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      }
+    }),
+    listCheckpoints: (sessionId) => list("checkpoint").map((value) => workspaceCheckpointSchema.parse(value)).filter((checkpoint) => checkpoint.sessionId === sessionId).map(summary),
+    listRestores: (sessionId) => list("restore").map((value) => workspaceRestoreOperationSchema.parse(value)).filter((operation) => operation.checkpoint.sessionId === sessionId).map((operation) => ({
+      id: operation.id,
+      checkpointId: operation.checkpoint.id,
+      proposalId: operation.proposalId,
+      stage: operation.stage,
+      ...operation.forkSessionId ? { forkSessionId: operation.forkSessionId } : {}
+    })),
+    inspectCheckpoint: async (id) => {
+      const checkpoint = workspaceCheckpointSchema.parse(load("checkpoint", id));
+      const files = await Promise.all(checkpoint.files.map(async (file) => {
+        try {
+          const current = await read(file.path);
+          if (current.mode !== file.mode)
+            return { path: file.path, status: "mode-conflict" };
+          return {
+            path: file.path,
+            status: "available",
+            before: current.content,
+            after: file.content,
+            expectedDigest: current.digest,
+            afterDigest: file.digest,
+            mode: file.mode
+          };
+        } catch {
+          return { path: file.path, status: "unavailable" };
+        }
+      }));
+      return {
+        checkpoint: summary(checkpoint),
+        files,
+        coverage: {
+          existingTextOnly: true,
+          maxFiles: 20,
+          maxFileBytes: 65536,
+          creation: false,
+          deletion: false,
+          binary: false,
+          modeRollback: false,
+          fullWorkspaceSnapshot: false
+        }
+      };
+    },
+    previewRestore: async (id) => {
+      const operation = getOperation(id);
+      for (const file of operation.checkpoint.files) {
+        if ((await read(file.path)).mode !== file.mode)
+          throw new Error(`Restore mode conflict: ${file.path}.`);
+      }
+      return workspace.previewPatch(proposal(operation));
+    },
+    capture: async (input) => withWorkspaceMutation(workspace.root, async () => {
+      await validateTurn(input);
+      if (input.paths.length === 0 || input.paths.length > 20 || new Set(input.paths).size !== input.paths.length)
+        throw new Error("Capture requires 1 to 20 unique existing text files.");
+      const files = [];
+      for (const target of input.paths)
+        files.push(await read(target));
+      const checkpoint = workspaceCheckpointSchema.parse({ id: randomUUID(), sessionId: input.sessionId, turnId: input.turnId, files });
+      save("checkpoint", checkpoint);
+      return checkpoint;
+    }),
+    prepareRestore: async (checkpointId, expectedCurrent) => withWorkspaceMutation(workspace.root, async () => {
+      const checkpoint = workspaceCheckpointSchema.parse(load("checkpoint", checkpointId));
+      await validateTurn(checkpoint);
+      if (Object.keys(expectedCurrent).length !== checkpoint.files.length)
+        throw new Error("Provide exact post-agent digests for every captured file.");
+      for (const file of checkpoint.files) {
+        const current = await read(file.path);
+        if (current.digest !== expectedCurrent[file.path] || current.mode !== file.mode)
+          throw new Error(`Restore conflicts with current content or mode: ${file.path}.`);
+      }
+      const changes = checkpoint.files.map((file) => ({ path: file.path, expectedDigest: expectedCurrent[file.path], content: file.content }));
+      const preview = createEditProposal({ changes });
+      const operation = workspaceRestoreOperationSchema.parse({
+        id: randomUUID(),
+        checkpoint,
+        proposalId: preview.proposalId,
+        expected: expectedCurrent,
+        stage: "prepared"
+      });
+      save("restore", operation);
+      return { operation, proposal: { ...preview, changes } };
+    }),
+    applyRestore: async (id, reviewedProposalId) => withWorkspaceMutation(workspace.root, async () => {
+      const operation = getOperation(id);
+      if (operation.proposalId !== reviewedProposalId)
+        throw new Error("Restore requires the reviewed proposal identity.");
+      const patch = proposal(operation);
+      if (operation.stage === "completed")
+        return operation;
+      if (operation.stage === "forking")
+        throw new Error(`Fork outcome uncertain. Inspect child sessions titled restore:${operation.id} and call recoverFork with the exact child ID; no files changed.`);
+      const current = [];
+      for (const file of operation.checkpoint.files) {
+        const found = await read(file.path);
+        if (found.mode !== file.mode)
+          throw new Error(`Restore mode conflict: ${file.path}.`);
+        current.push(found);
+      }
+      const beforeApply = current.every((file) => file.digest === operation.expected[file.path]);
+      const afterApply = current.every((file) => file.digest === operation.checkpoint.files.find((entry) => entry.path === file.path)?.digest);
+      if (["applying", "applied"].includes(operation.stage) && afterApply) {
+        operation.stage = "completed";
+        save("restore", operation);
+        return operation;
+      }
+      if (!beforeApply || operation.stage === "applied")
+        throw new Error("Restore conflicts with subsequent edits or a partially applied filesystem operation; manual recovery required.");
+      if (operation.stage === "prepared") {
+        const source = await validateTurn(operation.checkpoint);
+        operation.stage = "forking";
+        save("restore", operation);
+        const fork = await sessions.fork(source.sessionId, {
+          atTurnId: operation.checkpoint.turnId,
+          expectedRevision: source.revision,
+          title: `restore:${operation.id}`
+        });
+        operation.forkSessionId = fork.sessionId;
+        operation.stage = "forked";
+        save("restore", operation);
+      }
+      if (!operation.forkSessionId)
+        throw new Error("Restore has no recorded conversation fork.");
+      operation.stage = "applying";
+      save("restore", operation);
+      await workspace.applyPatchWithModes(patch, new Map(operation.checkpoint.files.map((file) => [file.path, { beforeMode: file.mode, afterMode: file.mode }])));
+      operation.stage = "applied";
+      save("restore", operation);
+      operation.stage = "completed";
+      save("restore", operation);
+      return operation;
+    }),
+    recoverFork: async (id, forkSessionId) => withWorkspaceMutation(workspace.root, async () => {
+      const operation = getOperation(id);
+      const fork = await sessions.get(forkSessionId);
+      if (operation.stage !== "forking" || !fork || fork.parentSessionId !== operation.checkpoint.sessionId || fork.forkedFromTurnId !== operation.checkpoint.turnId || fork.title !== `restore:${operation.id}`)
+        throw new Error("Fork does not match this interrupted restore.");
+      operation.forkSessionId = forkSessionId;
+      operation.stage = "forked";
+      save("restore", operation);
+      return operation;
+    })
+  };
+};
+
+// src/runtime/runtime-instructions.ts
+var withRuntimeInstruction = (messages, text) => {
+  const firstConversation = messages.findIndex((message) => message.role !== "system");
+  const at = firstConversation === -1 ? messages.length : firstConversation;
+  return [...messages.slice(0, at), { role: "system", parts: [{ type: "text", text }] }, ...messages.slice(at)];
+};
+var withFreshSystemInstructions = (input, hostInstructions) => {
+  if ("state" in input || !input.messages?.length)
+    return input;
+  const firstConversation = input.messages.findIndex((message) => message.role !== "system");
+  const count = firstConversation === -1 ? input.messages.length : firstConversation;
+  const leading = input.messages.slice(0, count);
+  if (!count || leading.some((message) => message.parts.some((part) => part.type !== "text")))
+    return input;
+  let text = leading.flatMap((message) => message.parts.flatMap((part) => part.type === "text" ? [part.text] : [])).join(`
+
+`);
+  const known = hostInstructions?.trim();
+  if (known && (text === known || text.startsWith(known + `
+
+`)))
+    text = text.slice(known.length).replace(/^\n\n/, "");
+  return { ...input, system: [input.system, text].filter((value) => value !== undefined && value !== "").join(`
+
+`), messages: input.messages.slice(count) };
+};
+
+// src/runtime/runtime-policy.ts
+import { createBudgetGuard, createProductionSafetyPolicy } from "@zhivex-ai/agents";
+var effectiveRuntimeBudget = (budget) => {
+  const { unlimitedTokens, maxInputTokens, maxOutputTokens, maxTotalTokens, ...nonTokenBudget } = budget;
+  return unlimitedTokens ? nonTokenBudget : { ...nonTokenBudget, maxInputTokens, maxOutputTokens, maxTotalTokens };
+};
+var createRuntimeBudget = (budget, transportTokens) => {
+  const durable = createBudgetGuard(effectiveRuntimeBudget(budget));
+  const transport = transportTokens ? durable : createBudgetGuard({
+    maxSteps: budget.maxSteps,
+    maxToolCalls: budget.maxToolCalls,
+    maxToolErrors: budget.maxToolErrors,
+    includeChildRuns: budget.includeChildRuns
+  });
+  return { ...transport, inputGuardrail: durable.inputGuardrail, outputGuardrail: durable.outputGuardrail };
+};
+var runtimeManifest = (config, tools, role = "primary") => ({
+  schemaVersion: 2,
+  policyVersion: "assistant-v3-durable-closure",
+  role,
+  requireVerifiedDelivery: role === "primary" && config.requireVerifiedDelivery,
+  ...role === "primary" && config.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {},
+  backend: config.execution.backend,
+  tools: [...tools].sort(),
+  budget: { ...role === "primary" ? config.budget : config.orchestration.childBudget },
+  timeoutMs: role === "primary" ? config.timeoutMs : config.orchestration.childTimeoutMs,
+  closureController: role === "primary" && config.requireVerifiedDelivery,
+  contextEnabled: config.context.enabled
+});
+var childRuntimeSafety = (config) => createProductionSafetyPolicy({
+  budget: createRuntimeBudget(config.orchestration.childBudget, false),
+  toolExecution: { ...harnessToolExecution, parallel: false }
+});
+var createCheckpointTokenCap = (limits, usage, transportTokens = true, options = {}) => {
+  const observed = {
+    inputTokens: options.initialUsage?.inputTokens ?? 0,
+    outputTokens: options.initialUsage?.outputTokens ?? 0,
+    totalTokens: options.initialUsage?.totalTokens ?? (options.initialUsage?.inputTokens ?? 0) + (options.initialUsage?.outputTokens ?? 0)
+  };
+  const cap = async (input, auxiliary = false) => {
+    if (limits.unlimitedTokens)
+      return;
+    const persisted = await usage();
+    for (const key of ["inputTokens", "outputTokens", "totalTokens"]) {
+      const value = persisted?.[key] ?? (key === "totalTokens" ? (persisted?.inputTokens ?? 0) + (persisted?.outputTokens ?? 0) : 0);
+      observed[key] = Math.max(observed[key], value);
+    }
+    const additional = await options.additionalUsage?.();
+    const remainingOutput = limits.maxOutputTokens - observed.outputTokens - (additional?.outputTokens ?? 0);
+    const remainingInput = limits.maxInputTokens - observed.inputTokens - (additional?.inputTokens ?? 0);
+    const remainingTotal = limits.maxTotalTokens - observed.totalTokens - (additional?.totalTokens ?? 0);
+    if (remainingInput <= 0)
+      throw new Error("maxInputTokens budget exhausted");
+    if (remainingOutput <= 0)
+      throw new Error("maxOutputTokens budget exhausted");
+    if (remainingTotal <= 0)
+      throw new Error("maxTotalTokens budget exhausted");
+    let predicted = estimateRequestTokens(input);
+    if (!auxiliary && options.closeOnBudget && (observed.inputTokens + predicted > limits.maxInputTokens * 0.7 || observed.outputTokens >= limits.maxOutputTokens * 0.7 || observed.totalTokens + predicted > limits.maxTotalTokens * 0.7)) {
+      delete input.tools;
+      delete input.toolChoice;
+      input.messages = withRuntimeInstruction(input.messages, "The run is approaching its cumulative token budget. Finish now using only the evidence already collected. State what was established and what remains unverified; do not claim that unfinished work is complete. No further tools are available.");
+      predicted = estimateRequestTokens(input);
+    }
+    if (predicted > remainingInput)
+      throw new Error("maxInputTokens budget exhausted");
+    if (predicted >= remainingTotal)
+      throw new Error("maxTotalTokens budget exhausted");
+    if (transportTokens || auxiliary)
+      input.maxTokens = Math.min(input.maxTokens ?? remainingOutput, remainingOutput, remainingTotal - predicted);
+  };
+  const record = (reported, enforce = true) => {
+    observed.inputTokens += reported?.inputTokens ?? 0;
+    observed.outputTokens += reported?.outputTokens ?? 0;
+    const sum = (reported?.inputTokens ?? 0) + (reported?.outputTokens ?? 0);
+    observed.totalTokens += Number.isSafeInteger(reported?.totalTokens) && reported.totalTokens >= 0 ? Math.max(reported.totalTokens, sum) : sum;
+    if (limits.unlimitedTokens || !enforce)
+      return;
+    if (observed.inputTokens > limits.maxInputTokens)
+      throw new Error("maxInputTokens budget exceeded");
+    if (observed.outputTokens > limits.maxOutputTokens)
+      throw new Error("maxOutputTokens budget exceeded");
+    if (observed.totalTokens > limits.maxTotalTokens)
+      throw new Error("maxTotalTokens budget exceeded");
+  };
+  return {
+    name: "harness-checkpoint-token-cap",
+    observed,
+    auxiliary: () => ({ name: "harness-utility-token-cap", async wrapGenerate(context, next) {
+      await cap(context.input, true);
+      const result = await next();
+      record(result.usage, false);
+      return result;
+    } }),
+    async wrapGenerate(context, next) {
+      await cap(context.input);
+      const result = await next();
+      record(result.usage);
+      return result;
+    },
+    async wrapStream(context, next) {
+      await cap(context.input);
+      const stream = await next();
+      return async function* () {
+        let recorded = false;
+        for await (const event of stream) {
+          if (event.type === "finish" && !recorded) {
+            record(event.usage);
+            recorded = true;
+          }
+          yield event;
+        }
+      }();
+    }
+  };
+};
+
+// src/runtime/repair-progress.ts
+import { createHash as createHash2 } from "node:crypto";
+import { posix } from "node:path";
+import { z as z2 } from "zod";
+var REPAIR_PROGRESS_KEY = "zhivexRepairProgress";
+var CLOSURE_READ_LIMIT = 4;
+var CLOSURE_COMMAND_LIMIT = 3;
+var savedProgress = z2.object({
+  closureReads: z2.number().int().min(0),
+  closureCommands: z2.number().int().min(0),
+  enteredClosure: z2.boolean(),
+  plannedPaths: z2.array(z2.string().max(240)).max(8),
+  seen: z2.array(z2.tuple([z2.string().max(128), z2.object({ output: z2.string().length(64), count: z2.number().int().min(1) })])).max(128),
+  lines: z2.array(z2.tuple([z2.string().length(64), z2.number().int().min(1)])).max(256).default([])
+});
+var observations = new Set(["inspect_environment_patch", "mutation_audit", "git_diff", "read_task", "environment_status", "load_skill", "propose_edits"]);
+var reads = new Set(["list_files", "read_file", "read_files", "search_files", "search_many"]);
+var canonical = (value) => {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+};
+var hash = (value) => createHash2("sha256").update(canonical(value)).digest("hex");
+var createRepairProgress = (usage, limits, metadata) => {
+  const restored = metadata?.[REPAIR_PROGRESS_KEY] === undefined ? undefined : savedProgress.parse(metadata[REPAIR_PROGRESS_KEY]);
+  let closureReads = restored?.closureReads ?? 0, closureCommands = restored?.closureCommands ?? 0;
+  let plannedPaths = restored?.plannedPaths ?? [];
+  let outputStep = -1, outputCharacters = 0;
+  const seen = new Map(restored?.seen);
+  const linesSeen = new Map(restored?.lines);
+  const stats = { repeatedResults: 0, suppressedResults: 0, blockedBroadCalls: 0, enteredClosure: restored?.enteredClosure ?? false, phase: plannedPaths.length ? "repair" : "explore", blockedPhaseCalls: 0, planRecorded: !!plannedPaths.length };
+  const snapshot = () => ({ closureReads, closureCommands, enteredClosure: stats.enteredClosure, plannedPaths: [...plannedPaths], seen: [...seen], lines: [...linesSeen] });
+  const workingContext = () => ({
+    plannedPaths: plannedPaths.map((value) => posix.normalize(value)),
+    closureReadsRemaining: Math.max(0, CLOSURE_READ_LIMIT - closureReads),
+    closureCommandsRemaining: Math.max(0, CLOSURE_COMMAND_LIMIT - closureCommands)
+  });
+  const closing = () => {
+    const used = usage();
+    stats.enteredClosure ||= used.inputTokens + (used.predictedInputTokens ?? 0) >= limits.inputTokens * 0.7 || used.outputTokens >= limits.outputTokens * 0.7;
+    return stats.enteredClosure;
+  };
+  const wrapTools = (tools) => Object.fromEntries(Object.entries(tools).map(([name, definition]) => {
+    if (!("execute" in definition))
+      return [name, definition];
+    return [name, { ...definition, async execute(input, context) {
+      try {
+        if (name === "repair_plan") {
+          const plan = input;
+          const result = await definition.execute(input, context);
+          plannedPaths = plan.paths ?? [];
+          stats.planRecorded = true;
+          stats.phase = "explore";
+          return result;
+        }
+        if (observations.has(name))
+          return definition.execute(input, context);
+        if (name.startsWith("verify_"))
+          stats.phase = "verify";
+        if (!reads.has(name)) {
+          if (closing() && name.startsWith("run_environment") && ++closureCommands > CLOSURE_COMMAND_LIMIT) {
+            stats.blockedPhaseCalls++;
+            throw new Error("REPAIR_PHASE_BUDGET: the closure command allowance is exhausted. Use an inspected patch and the approved verifier, or report the incomplete repair.");
+          }
+          seen.clear();
+          linesSeen.clear();
+          return definition.execute(input, context);
+        }
+        const requestedPath = input && typeof input === "object" ? input.path : undefined;
+        const pathInput = input && typeof input === "object" ? input : {};
+        const requestedPaths = name === "read_files" && Array.isArray(pathInput.files) ? pathInput.files.map((file) => file.path) : [requestedPath];
+        const normalizedPaths = requestedPaths.filter((value) => typeof value === "string").map((value) => posix.normalize(value));
+        const normalizedPlan = plannedPaths.map((value) => posix.normalize(value));
+        const globalSearch = requestedPath === undefined || typeof requestedPath === "string" && posix.normalize(requestedPath || ".") === ".";
+        if (closing() && (name === "list_files" || ["search_files", "search_many"].includes(name) && globalSearch)) {
+          stats.blockedBroadCalls++;
+          throw new Error("REPAIR_CLOSURE: broad discovery is paused to preserve the remaining budget. Use known file paths for focused reads/searches, reproduce the issue, repair and verify. If context is insufficient, report the limitation; do not guess a patch.");
+        }
+        if (closing() && plannedPaths.length && normalizedPaths.some((value) => !normalizedPlan.includes(value))) {
+          stats.blockedPhaseCalls++;
+          throw new Error("REPAIR_PLAN_SCOPE: use a file recorded in repair_plan or explicitly revise the hypothesis first.");
+        }
+        if (closing() && closureReads >= CLOSURE_READ_LIMIT) {
+          stats.blockedPhaseCalls++;
+          throw new Error("REPAIR_PHASE_BUDGET: the closure read allowance is exhausted. Recover task constraints with read_task, repair known files, and verify or report the limitation.");
+        }
+        if (closing())
+          closureReads++;
+        const output = await definition.execute(input, context);
+        if (outputStep !== context.step) {
+          outputStep = context.step;
+          outputCharacters = 0;
+        }
+        outputCharacters += JSON.stringify(output).length;
+        if (outputCharacters > 32000)
+          throw new Error("TOOL_OUTPUT_BUDGET: this turn's read output is full. Request a narrower slice on a new turn.");
+        const data = output && typeof output === "object" ? output : {};
+        const evidence = Array.isArray(data.matches) && data.matches.length ? data.matches : Array.isArray(data.results) ? data.results.flatMap((r) => r.matches ?? []) : undefined;
+        const key = evidence?.length ? hash({ evidence }) : hash({ name, input });
+        const fingerprint = hash(evidence?.length ? evidence : output);
+        const prior = seen.get(key);
+        const count = prior?.output === fingerprint ? prior.count + 1 : 1;
+        seen.delete(key);
+        seen.set(key, { output: fingerprint, count });
+        if (seen.size > 128)
+          seen.delete(seen.keys().next().value);
+        if (count > 1)
+          stats.repeatedResults++;
+        const files = Array.isArray(data.files) ? data.files : [data];
+        const lineKeys = files.flatMap((file) => typeof file.path === "string" && typeof file.digest === "string" && typeof file.content === "string" ? file.content.split(`
+`).map((line) => hash({ path: file.path, digest: file.digest, line })) : []);
+        const overlapping = lineKeys.length > 0 && lineKeys.length <= 256 && lineKeys.every((key2) => (linesSeen.get(key2) ?? 0) >= 2);
+        for (const key2 of new Set(lineKeys.slice(0, 256))) {
+          const count2 = (linesSeen.get(key2) ?? 0) + 1;
+          linesSeen.delete(key2);
+          linesSeen.set(key2, count2);
+          if (linesSeen.size > 256)
+            linesSeen.delete(linesSeen.keys().next().value);
+        }
+        if (count > 2 || overlapping) {
+          stats.suppressedResults++;
+          throw new Error("REPEATED_EXPLORATION: this request returned unchanged or fully overlapping evidence at least three times. Its repeated payload was omitted. Request new evidence or proceed to reproduction and verification. No cached source was substituted.");
+        }
+        return output;
+      } finally {
+        if (context.metadata)
+          context.metadata[REPAIR_PROGRESS_KEY] = snapshot();
+      }
+    } }];
+  }));
+  return { stats, closing, wrapTools, snapshot, workingContext };
+};
+
+// src/runtime/repair-controller.ts
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { z as z3 } from "zod";
+import { createRedactionPolicy } from "@zhivex-ai/agents";
+var REPAIR_CONTROLLER_KEY = "zhivexRepairController";
+var digestSchema = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
+var stateSchema = z3.object({
+  schemaVersion: z3.literal(1),
+  phase: z3.enum(["explore", "reproduce", "candidate", "verify", "recover", "delivered", "incomplete"]),
+  candidate: digestSchema.nullable(),
+  revision: z3.number().int().nonnegative(),
+  verifier: verifierSchema.nullable(),
+  verifierRequests: z3.number().int().nonnegative(),
+  verificationFailures: z3.number().int().nonnegative(),
+  completionReminders: z3.number().int().min(0).max(1).default(0),
+  planRequired: z3.boolean().default(false),
+  workBudgetClosure: z3.boolean().default(false),
+  requireVerifiedDelivery: z3.boolean().default(false),
+  hypothesis: z3.string().max(1000),
+  nextCheck: z3.string().max(500),
+  receipts: z3.array(z3.object({
+    commandId: z3.string().max(128),
+    purpose: z3.string().max(500),
+    argvDigest: digestSchema,
+    candidate: digestSchema.nullable(),
+    exitCode: z3.number().int(),
+    verified: z3.boolean()
+  })).max(8)
+});
+var mutations = new Set(["apply_reviewed_edits", "apply_reviewed_replacement", "apply_patch", "move_file", "quarantine_file", "restore_file"]);
+var commands = new Set(["run_environment_command", "run_environment_shell", "run_environment_batch"]);
+var terminal = new Set(["verify_and_apply_environment_patch", "verify_and_apply_reviewed_edits"]);
+var redact = createRedactionPolicy({ includeEmails: true });
+var sha = (value) => `sha256:${createHash3("sha256").update(JSON.stringify(value)).digest("hex")}`;
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var createRepairController = (metadata, oci, options = {}) => {
+  const state = metadata[REPAIR_CONTROLLER_KEY] === undefined ? stateSchema.parse({
+    schemaVersion: 1,
+    phase: "explore",
+    candidate: null,
+    revision: 0,
+    verifier: null,
+    verifierRequests: 0,
+    verificationFailures: 0,
+    hypothesis: "",
+    nextCheck: "",
+    receipts: []
+  }) : stateSchema.parse(metadata[REPAIR_CONTROLLER_KEY]);
+  state.requireVerifiedDelivery ||= options.requireVerifiedDelivery === true;
+  const snapshot = () => structuredClone(state);
+  const pending = () => state.candidate !== null && state.phase !== "delivered";
+  const closure = () => state.workBudgetClosure || state.planRequired || pending() || state.phase === "recover";
+  const completionPending = () => state.requireVerifiedDelivery && state.phase !== "delivered" || state.planRequired || pending() || state.verifier !== null && state.phase !== "delivered";
+  const markIncomplete = () => {
+    if (completionPending())
+      state.phase = "incomplete";
+  };
+  const verificationFailed = (attemptedVerification = true) => {
+    if (attemptedVerification)
+      state.verificationFailures++;
+    state.phase = "recover";
+    state.verifier = null;
+    state.verifierRequests = 0;
+  };
+  const wrapTools = (tools) => Object.fromEntries(Object.entries(tools).map(([name, tool]) => {
+    if (!("execute" in tool))
+      return [name, tool];
+    return [name, { ...tool, async execute(input, context) {
+      let executed = false;
+      try {
+        if (oci && mutations.has(name) && !state.verifier)
+          state.planRequired = true;
+        if (state.planRequired && !state.verifier && !["repair_plan", "read_task", "environment_status", "mutation_audit"].includes(name)) {
+          throw new Error("REPAIR_PLAN_REQUIRED: call repair_plan with exact verifier command, args and purpose before editing. No edit was executed. The verifier must assert the requested behavior; recording it is not approval.");
+        }
+        if (pending() && state.phase !== "recover" && !terminal.has(name) && !["repair_plan", "read_task", "inspect_environment_patch", "environment_status", "mutation_audit", "run_check"].includes(name)) {
+          throw new Error("REPAIR_VERIFICATION_REQUIRED: verify the existing candidate before further exploration; revise the plan after a failed check.");
+        }
+        executed = true;
+        const value = await tool.execute(input, context);
+        const output = record(value);
+        if (name === "repair_plan") {
+          const plan = record(input);
+          state.hypothesis = redact.redactText(String(plan.hypothesis ?? "")).slice(0, 1000);
+          state.nextCheck = redact.redactText(String(plan.nextCheck ?? "")).slice(0, 500);
+          if (plan.verifier !== undefined) {
+            state.verifier = verifierSchema.parse(plan.verifier);
+            if (state.planRequired) {
+              state.planRequired = false;
+              state.verifierRequests = 0;
+            }
+            if (pending())
+              state.phase = "candidate";
+          }
+        }
+        if (mutations.has(name) || commands.has(name)) {
+          const session = harnessExecutionSession(context);
+          const patch = session ? await session.inspectPatch() : undefined;
+          const candidate = patch ? patch.entries.length ? patch.patchId : null : mutations.has(name) ? sha(output) : state.candidate;
+          if (candidate !== state.candidate) {
+            state.revision++;
+            state.verifierRequests = 0;
+          }
+          state.candidate = candidate;
+          state.phase = candidate ? "candidate" : commands.has(name) ? "reproduce" : "explore";
+        }
+        if (name === "inspect_environment_patch" && Array.isArray(output.entries)) {
+          const candidate = output.entries.length ? digestSchema.parse(output.patchId) : null;
+          if (candidate !== state.candidate) {
+            state.revision++;
+            state.verifierRequests = 0;
+          }
+          state.candidate = candidate;
+          if (state.phase !== "recover")
+            state.phase = candidate ? "candidate" : "explore";
+        }
+        if (terminal.has(name) && typeof output.patchId === "string") {
+          const candidate = digestSchema.parse(output.patchId);
+          if (candidate !== state.candidate)
+            state.revision++;
+          state.candidate = candidate;
+        }
+        const verification = terminal.has(name) ? record(output.verification) : output;
+        if ((commands.has(name) || terminal.has(name) || name === "run_check") && Number.isSafeInteger(verification.exitCode)) {
+          const passed = verification.exitCode === 0 && verification.timedOut !== true;
+          state.receipts.push({
+            commandId: context?.toolCall?.id ?? `check_${randomUUID2()}`,
+            purpose: redact.redactText((state.verifier?.purpose ?? state.nextCheck) || "Command execution; requirement coverage not established").slice(0, 500),
+            argvDigest: sha(input),
+            candidate: state.candidate,
+            exitCode: verification.exitCode,
+            verified: passed && (terminal.has(name) || !oci && name === "run_check" && pending())
+          });
+          if (state.receipts.length > 8)
+            state.receipts.shift();
+          if (passed && (terminal.has(name) || !oci && name === "run_check" && pending()))
+            state.phase = "delivered";
+          else if (!passed && pending())
+            verificationFailed(terminal.has(name) || !oci && name === "run_check");
+        }
+        return value;
+      } catch (error) {
+        if (executed && (mutations.has(name) || commands.has(name) || terminal.has(name))) {
+          try {
+            const session = harnessExecutionSession(context);
+            const patch = session ? await session.inspectPatch() : undefined;
+            const candidate = patch ? patch.entries.length ? patch.patchId : null : sha({ failedTool: name, call: context?.toolCall?.id });
+            const changed = candidate !== state.candidate;
+            if (changed)
+              state.revision++;
+            state.candidate = candidate;
+            if (candidate !== null && (changed || pending())) {
+              const failure = record(record(error).verification);
+              if (Number.isSafeInteger(failure.exitCode)) {
+                state.receipts.push({
+                  commandId: context?.toolCall?.id ?? `check_${randomUUID2()}`,
+                  purpose: redact.redactText(state.verifier?.purpose ?? state.nextCheck).slice(0, 500),
+                  argvDigest: sha(input),
+                  candidate,
+                  exitCode: failure.exitCode,
+                  verified: false
+                });
+                if (state.receipts.length > 8)
+                  state.receipts.shift();
+              }
+              verificationFailed(terminal.has(name));
+            }
+          } catch {
+            state.candidate ??= sha({ uninspectedEffect: name, call: context?.toolCall?.id });
+            state.phase = "incomplete";
+          }
+        }
+        throw error;
+      } finally {
+        if (context?.metadata)
+          context.metadata[REPAIR_CONTROLLER_KEY] = snapshot();
+      }
+    } }];
+  }));
+  const prepare = (input, provider) => {
+    input.abortSignal?.throwIfAborted();
+    const sources = taskSources(metadata);
+    const latest = sources.at(-1);
+    const projection = {
+      activeRequest: latest ? { id: latest.id, excerpt: latest.text.slice(0, 1600), totalCharacters: latest.text.length } : null,
+      previousRequestIds: sources.slice(-4, -1).map((source) => source.id),
+      phase: state.phase,
+      candidate: state.candidate,
+      revision: state.revision,
+      planRequired: state.planRequired,
+      requireVerifiedDelivery: state.requireVerifiedDelivery,
+      workBudgetClosure: state.workBudgetClosure,
+      hypothesis: state.hypothesis,
+      nextCheck: state.nextCheck,
+      checks: state.receipts.slice(-2),
+      progress: options.progressContext?.() ?? null,
+      completionReminder: state.completionReminders > 0 ? "A final answer did not fulfill the repair. Continue the focused repair and verification; do not claim delivery without a verified candidate." : null
+    };
+    const workingState = { type: "text", text: "" };
+    const renderState = () => {
+      workingState.text = `[Harness working state; not approval]
+${JSON.stringify(projection)}
+Use read_task for complete constraints if the excerpt is incomplete. A candidate must be verified before completion.`;
+    };
+    renderState();
+    input.messages = [...input.messages, { role: "user", parts: [workingState] }];
+    if (oci && state.requireVerifiedDelivery && !pending() && ["explore", "reproduce"].includes(state.phase) && options.workBudgetReached?.(input)) {
+      state.workBudgetClosure = true;
+      projection.workBudgetClosure = true;
+      if (!state.verifier)
+        state.planRequired = true;
+      projection.planRequired = state.planRequired;
+      renderState();
+    }
+    if (state.phase === "incomplete")
+      throw new Error("REPAIR_INCOMPLETE: authorization or verification is missing.");
+    if (pending() && state.verificationFailures > 2)
+      throw new Error("REPAIR_VERIFICATION_RETRIES_EXHAUSTED");
+    if (state.planRequired && !state.verifier) {
+      if (state.verifierRequests >= 2)
+        throw new Error("REPAIR_PLAN_MISSING: register a concrete verifier before editing.");
+      if (!input.tools?.repair_plan)
+        throw new Error("REPAIR_VERIFIER_UNAVAILABLE");
+      state.verifierRequests++;
+      input.tools = Object.fromEntries(Object.entries(input.tools).filter(([name]) => ["repair_plan", "read_task"].includes(name)));
+      const supported = provider !== "qwen" || input.reasoning?.effort === "none" || input.providerOptions?.enable_thinking === false;
+      input.toolChoice = supported ? { type: "tool", toolName: "repair_plan" } : "auto";
+      return;
+    }
+    if (!pending()) {
+      if (completionPending()) {
+        const supported = provider !== "qwen" || input.reasoning?.effort === "none" || input.providerOptions?.enable_thinking === false;
+        input.toolChoice = supported ? "required" : "auto";
+      }
+      return;
+    }
+    if (oci && state.verifier && state.phase !== "recover" && input.tools?.verify_and_apply_environment_patch) {
+      state.phase = "verify";
+      return {
+        id: `controller_${randomUUID2()}`,
+        name: "verify_and_apply_environment_patch",
+        input: { patchId: state.candidate, command: state.verifier.command, args: state.verifier.args }
+      };
+    }
+    if (state.phase === "recover") {
+      const requiredChoiceSupported = provider !== "qwen" || input.reasoning?.effort === "none" || input.providerOptions?.enable_thinking === false;
+      input.toolChoice = requiredChoiceSupported ? "required" : "auto";
+    }
+    if (state.phase !== "recover") {
+      if (++state.verifierRequests > 2)
+        throw new Error("REPAIR_VERIFIER_MISSING: candidate retained without verification.");
+      const required = oci ? "repair_plan" : "run_check";
+      if (!input.tools?.[required])
+        throw new Error("REPAIR_VERIFIER_UNAVAILABLE");
+      input.tools = Object.fromEntries(Object.entries(input.tools).filter(([name]) => [required, "read_task"].includes(name)));
+      const namedChoiceSupported = provider !== "qwen" || input.reasoning?.effort === "none" || input.providerOptions?.enable_thinking === false;
+      input.toolChoice = namedChoiceSupported ? { type: "tool", toolName: required } : "auto";
+    }
+  };
+  const synthetic = (call) => ({
+    message: { role: "assistant", parts: [{ type: "tool-call", toolCall: call }] },
+    finishReason: "tool-calls",
+    providerFinishReason: "harness-controller",
+    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+  });
+  const remind = (input, reason, usage, sawTool) => {
+    input.abortSignal?.throwIfAborted();
+    if (reason !== "stop" || sawTool || !completionPending() || state.completionReminders >= 1 || !input.tools?.read_task || state.planRequired && state.verifierRequests >= 2 || pending() && state.phase !== "recover" && !state.verifier && state.verifierRequests >= 2 || !usage || ![usage.inputTokens, usage.outputTokens, usage.cachedInputTokens ?? 0].every((n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0))
+      return;
+    state.completionReminders++;
+    return { id: `controller_${randomUUID2()}`, name: "read_task", input: {} };
+  };
+  const middleware = {
+    name: "harness-repair-controller-v1",
+    async wrapGenerate(context, next) {
+      const call = prepare(context.input, context.model.provider);
+      if (call)
+        return synthetic(call);
+      const result = await next();
+      const messages = result.messages ?? (result.message ? [result.message] : []);
+      const reminder = remind(context.input, result.finishReason, result.usage, messages.some((m) => m.parts.some((p) => p.type === "tool-call" || p.type === "tool-result")));
+      if (!reminder)
+        return result;
+      const last = messages.at(-1);
+      const message = { role: "assistant", parts: [
+        ...last?.role === "assistant" ? last.parts : [],
+        { type: "tool-call", toolCall: reminder }
+      ] };
+      return {
+        ...result,
+        message,
+        messages: [...last?.role === "assistant" ? messages.slice(0, -1) : messages, message],
+        finishReason: "tool-calls",
+        providerFinishReason: "harness-completion-reminder"
+      };
+    },
+    async wrapStream(context, next) {
+      const call = prepare(context.input, context.model.provider);
+      if (!call) {
+        const stream = await next();
+        return async function* () {
+          let sawTool = false;
+          let finish;
+          for await (const event of stream) {
+            if (["tool-call", "tool-result", "tool-approval-request", "error"].includes(event.type))
+              sawTool = true;
+            if (event.type === "finish") {
+              if (finish)
+                throw new Error("REPAIR_AMBIGUOUS_STREAM: multiple terminal events.");
+              finish = event;
+              continue;
+            }
+            yield event;
+          }
+          if (finish) {
+            const reminder = remind(context.input, finish.finishReason, finish.usage, sawTool);
+            if (reminder)
+              yield { type: "tool-call", toolCall: reminder };
+            yield reminder ? { ...finish, finishReason: "tool-calls", providerFinishReason: "harness-completion-reminder" } : finish;
+          }
+        }();
+      }
+      return async function* () {
+        yield { type: "tool-call", toolCall: call };
+        yield { type: "finish", finishReason: "tool-calls", providerFinishReason: "harness-controller", usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } };
+      }();
+    }
+  };
+  return { state, snapshot, pending, completionPending, closure, markIncomplete, verificationFailed, wrapTools, middleware };
+};
+
+// src/runtime/runtime-checkpoints.ts
+var RUNTIME_DIAGNOSTICS_KEY = "zhivexRuntimeDiagnostics";
+var runtimeCheckpointStore = (store, runId, budget, progress, controller) => new Proxy(store, {
+  get(target, key) {
+    if (key === "save")
+      return async (...args) => {
+        const [state] = args;
+        if (state.runId === runId) {
+          if (state.status === "completed" && controller.completionPending()) {
+            controller.markIncomplete();
+            state.status = "failed";
+            state.outputText = "Repair incomplete: the candidate has not been verified and delivered.";
+            state.error = { message: "REPAIR_INCOMPLETE" };
+          }
+          state.metadata = {
+            ...state.metadata,
+            [MODEL_BUDGET_KEY]: budget.snapshot(),
+            [REPAIR_PROGRESS_KEY]: progress.snapshot(),
+            [REPAIR_CONTROLLER_KEY]: controller.snapshot(),
+            [RUNTIME_DIAGNOSTICS_KEY]: {
+              schemaVersion: 2,
+              requireVerifiedDelivery: controller.state.requireVerifiedDelivery,
+              budget: { ...budget.stats },
+              phase: controller.state.phase,
+              candidate: controller.state.candidate,
+              revision: controller.state.revision,
+              checks: controller.state.receipts,
+              contextMeasurements: budget.contextMetrics,
+              modelTimings: budget.modelTimings,
+              omittedContextMeasurements: budget.omittedContextMeasurements
+            }
+          };
+        }
+        return target.save(...args);
+      };
+    const value = Reflect.get(target, key, target);
+    return typeof value === "function" ? value.bind(target) : value;
+  }
+});
+var tokenUsageCheckpointStore = (store, runId, observed) => new Proxy(store, {
+  get(target, key) {
+    if (key === "save")
+      return async (...args) => {
+        const [state] = args;
+        if (state.runId === runId && state.status === "failed") {
+          const usage = observed();
+          state.usage = {
+            ...state.usage,
+            inputTokens: Math.max(state.usage?.inputTokens ?? 0, usage.inputTokens ?? 0),
+            outputTokens: Math.max(state.usage?.outputTokens ?? 0, usage.outputTokens ?? 0),
+            totalTokens: Math.max(state.usage?.totalTokens ?? 0, usage.totalTokens ?? 0)
+          };
+        }
+        return target.save(...args);
+      };
+    const value = Reflect.get(target, key, target);
+    return typeof value === "function" ? value.bind(target) : value;
+  }
+});
+
+// src/persistence/operations.ts
+import { chmod, lstat, mkdir, open } from "node:fs/promises";
+import path2 from "node:path";
+import {
+  cancelAgentRun,
+  cancelAgentRunTree,
+  createRedactionPolicy as createRedactionPolicy2,
+  getAgentBudgetStatus
+} from "@zhivex-ai/agents";
+import {
+  createAgentTraceArtifact,
+  createHierarchicalAgentTrace,
+  createFileAgentMemoryStore,
+  createFileAgentRunStore,
+  createProductionTraceOptions,
+  createSqliteAgentMemoryStore,
+  createSqliteAgentRunStore
+} from "@zhivex-ai/agents/ops";
+import { createAgentRunLedger } from "@zhivex-ai/agents/control-plane";
+var budgetScopeFor = (config) => ({
+  tenantId: config.scope.tenantId,
+  ...config.scope.userId ? { userId: config.scope.userId } : {},
+  namespace: "__zhivex_budget__"
+});
+var withBudgetLedgerStore = (primary, budget, config) => {
+  const scope = budgetScopeFor(config);
+  const budgetScope = (value) => value?.namespace === scope.namespace && value.tenantId === scope.tenantId && (value.userId ?? undefined) === (scope.userId ?? undefined);
+  const assertId = (id) => {
+    if (!/^budget_[a-f0-9]{64}$/.test(id))
+      throw new HarnessStateConflictError("Invalid budget ledger identity.");
+  };
+  return {
+    ...primary,
+    load: async (id, requestedScope) => {
+      if (!budgetScope(requestedScope))
+        return primary.load(id, requestedScope);
+      assertId(id);
+      return budget.load(id, requestedScope);
+    },
+    save: async (state, options) => {
+      if (!budgetScope(state.scope))
+        return primary.save(state, options);
+      assertId(state.runId);
+      if (state.provider !== "zhivex" || state.modelId !== "budget-coordinator" || state.metadata?.budgetCoordinator !== true) {
+        throw new HarnessStateConflictError("Only SDK budget ledger states may use the reserved namespace.");
+      }
+      return budget.save(state, options);
+    }
+  };
+};
+var HARNESS_SQLITE_FILE = "operations.sqlite";
+var HARNESS_OPERATIONS_SCHEMA_VERSION = 1;
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "cancelled", "timed_out"];
+var runSummary = (state) => {
+  const consumption = getAgentBudgetStatus(state, { includeChildRuns: false }).consumption;
+  return {
+    runId: state.runId,
+    revision: state.revision ?? 0,
+    status: state.status,
+    provider: state.provider,
+    model: state.modelId,
+    agentId: state.agentId,
+    parentRunId: state.parentRunId,
+    idempotencyKey: state.idempotencyKey,
+    scope: state.scope,
+    steps: consumption.steps,
+    toolCalls: consumption.toolCalls,
+    toolErrors: consumption.toolErrors,
+    pendingApprovals: state.pendingApprovals.length,
+    compactions: state.compactions?.length ?? 0,
+    childRuns: state.childRuns?.length ?? 0,
+    usage: state.usage,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    cancelledAt: state.cancelledAt,
+    cancellationReason: state.cancellationReason
+  };
+};
+var listHarnessRuns = async (store, config, query = {}) => {
+  if (!store.list) {
+    throw new HarnessStateConflictError(`The ${config.storeBackend} run store does not support listing.`);
+  }
+  const page = await store.list(query, config.scope);
+  return {
+    schemaVersion: HARNESS_OPERATIONS_SCHEMA_VERSION,
+    kind: "run-list",
+    scope: config.scope,
+    backend: config.storeBackend,
+    runs: page.items.map(runSummary),
+    ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+  };
+};
+var inspectHarnessRun = async (store, config, runId) => {
+  const state = await store.load(runId, config.scope);
+  if (!state) {
+    throw new HarnessStateConflictError(`Run ${runId} was not found in ${config.stateDirectory}.`);
+  }
+  const redaction = createRedactionPolicy2({ includeEmails: true });
+  const traceOptions = createProductionTraceOptions({
+    includeMessages: false,
+    includeToolInputs: false,
+    includeToolOutputs: false,
+    includeApprovalArguments: false,
+    includeOutputText: false,
+    outputPreviewLength: 240,
+    redaction
+  });
+  const rawLedger = createAgentRunLedger(state, {
+    includeTimeline: true,
+    includeInput: false,
+    includeOutput: false,
+    includeMetadata: false,
+    outputPreviewLength: 240,
+    redaction,
+    ...config.costBudget ? {
+      pricing: {
+        inputCostPer1kTokens: config.costBudget.inputCostPer1kTokens,
+        outputCostPer1kTokens: config.costBudget.outputCostPer1kTokens,
+        currency: "USD"
+      }
+    } : {},
+    trace: traceOptions
+  });
+  const { outputText: _ledgerOutput, ...ledgerSnapshot } = rawLedger.snapshot;
+  const ledger = { ...rawLedger, snapshot: ledgerSnapshot };
+  const snapshot = ledgerSnapshot;
+  const journal = await store.listToolCalls?.(runId, config.scope) ?? [];
+  const hierarchyStore = {
+    load: (candidateRunId) => store.load(candidateRunId, config.scope),
+    save: (candidateState, options) => store.save(candidateState, options),
+    findByParentRunId: (parentRunId) => store.findByParentRunId?.(parentRunId, config.scope) ?? []
+  };
+  const hierarchy = await createHierarchicalAgentTrace(hierarchyStore, runId, traceOptions);
+  return {
+    schemaVersion: HARNESS_OPERATIONS_SCHEMA_VERSION,
+    kind: "run-inspection",
+    run: runSummary(state),
+    budget: getAgentBudgetStatus(state, effectiveRuntimeBudget(config.budget)),
+    snapshot,
+    trace: createAgentTraceArtifact(state, traceOptions),
+    hierarchy,
+    ledger,
+    runtimeDiagnostics: inspectRuntimeDiagnostics(state.metadata?.[RUNTIME_DIAGNOSTICS_KEY]),
+    usageLedger: inspectUsageLedger(state.metadata?.[USAGE_LEDGER_KEY]),
+    effectiveRuntime: inspectRuntimeManifest(state.metadata?.effectiveRuntime),
+    toolJournal: journal.map((entry) => ({
+      toolCallId: entry.toolCallId,
+      toolName: entry.toolName,
+      status: entry.status,
+      revision: entry.revision,
+      startedAt: entry.startedAt,
+      completedAt: entry.completedAt,
+      updatedAt: entry.updatedAt,
+      error: entry.error ? { message: redaction.redactText(entry.error.message) } : undefined
+    }))
+  };
+};
+var cancelHarnessRun = async (store, config, runId, options = {}) => {
+  const cancellationOptions = {
+    scope: config.scope,
+    mode: options.final ? "final" : "request",
+    ...options.reason ? { reason: options.reason } : {}
+  };
+  const result = options.cascade ? await cancelAgentRunTree(store, runId, cancellationOptions) : await cancelAgentRun(store, runId, cancellationOptions);
+  if (!result || "parent" in result && !result.parent) {
+    throw new HarnessStateConflictError(`Run ${runId} was not found in ${config.stateDirectory}.`);
+  }
+  return {
+    schemaVersion: HARNESS_OPERATIONS_SCHEMA_VERSION,
+    kind: "run-cancellation",
+    cascade: options.cascade ?? false,
+    ...options.cascade ? {
+      parent: runSummary(result.parent),
+      children: result.children.map(runSummary)
+    } : { run: runSummary(result) }
+  };
+};
+var cleanupHarnessRuns = async (store, config, options) => {
+  if (!store.deleteExpired) {
+    throw new HarnessStateConflictError(`The ${config.storeBackend} run store does not support retention cleanup.`);
+  }
+  const statuses = options.statuses?.length ? options.statuses : [...TERMINAL_RUN_STATUSES];
+  const deleted = await store.deleteExpired({
+    before: options.before,
+    statuses,
+    limit: options.limit ?? 1000
+  }, config.scope);
+  return {
+    schemaVersion: HARNESS_OPERATIONS_SCHEMA_VERSION,
+    kind: "run-cleanup",
+    before: options.before,
+    statuses,
+    deleted
+  };
+};
+var emptyMigration = () => ({
+  scannedRuns: 0,
+  migratedRuns: 0,
+  migratedToolCalls: 0
+});
+var shouldMigrateLegacyRuns = (config, requested) => requested ?? (config.scope.tenantId === "local" && config.scope.userId === undefined && config.scope.namespace === defaultHarnessNamespace(config.workspace));
+var sqliteAdapter = (database) => ({
+  exec(sql) {
+    return database.exec(sql);
+  },
+  prepare(sql) {
+    const statement = database.query(sql);
+    const bindings = (params) => params === undefined ? [] : Array.isArray(params) ? params : [params];
+    return {
+      run(params) {
+        return statement.run(...bindings(params));
+      },
+      get(params) {
+        return statement.get(...bindings(params));
+      },
+      all(params) {
+        return statement.all(...bindings(params));
+      }
+    };
+  }
+});
+var ensurePrivateStateDirectory = async (directory) => {
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const entry = await lstat(directory);
+  if (entry.isSymbolicLink() || !entry.isDirectory()) {
+    throw new HarnessWorkspaceError(`The state directory must be a real directory: ${directory}.`);
+  }
+  await chmod(directory, 448);
+};
+var migrateJournalEntry = (entry, state, config) => ({
+  ...entry,
+  runId: state.runId,
+  scope: config.scope
+});
+var migrateLegacyFileRuns = async (directory, target, config) => {
+  const source = createFileAgentRunStore({ directory });
+  const result = emptyMigration();
+  let cursor;
+  do {
+    const page = await source.list?.({ limit: 100, ...cursor ? { cursor } : {} });
+    if (!page) {
+      break;
+    }
+    for (const legacyState of page.items) {
+      result.scannedRuns += 1;
+      if (legacyState.budgetCoordinatorId || legacyState.metadata?.budgetCoordinator === true) {
+        throw new HarnessStateConflictError("Legacy file migration cannot rebind a shared budget identity; retain the original scoped store.");
+      }
+      const existing = await target.load(legacyState.runId, config.scope);
+      if (existing) {
+        continue;
+      }
+      const migratedState = {
+        ...legacyState,
+        scope: config.scope,
+        metadata: {
+          ...legacyState.metadata ?? {},
+          migratedFrom: "0.3-file-store"
+        }
+      };
+      await target.save(migratedState);
+      result.migratedRuns += 1;
+      const journal = await source.listToolCalls?.(legacyState.runId, legacyState.scope) ?? [];
+      for (const entry of journal) {
+        await target.saveToolCall?.(migrateJournalEntry(entry, migratedState, config));
+        result.migratedToolCalls += 1;
+      }
+    }
+    cursor = page.nextCursor;
+  } while (cursor);
+  return result;
+};
+var openHarnessPersistence = async (config, options = {}) => {
+  if (config.scope.namespace === "__zhivex_budget__")
+    throw new HarnessStateConflictError("The budget ledger namespace is reserved.");
+  await validateStateDirectory(config.workspace, config.stateDirectory);
+  await ensurePrivateStateDirectory(config.stateDirectory);
+  await protectStateFromGit(config.workspace, config.stateDirectory);
+  if (config.storeBackend === "file") {
+    const store = withBudgetLedgerStore(createFileAgentRunStore({ directory: config.stateDirectory, scope: config.scope }), createFileAgentRunStore({ directory: config.stateDirectory, scope: budgetScopeFor(config) }), config);
+    const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
+    return {
+      backend: "file",
+      store,
+      memory: createFileAgentMemoryStore({
+        directory: path2.join(config.stateDirectory, "memory"),
+        scope: config.scope
+      }),
+      migration,
+      close() {}
+    };
+  }
+  const databasePath = path2.join(config.stateDirectory, HARNESS_SQLITE_FILE);
+  let databaseEntry;
+  try {
+    const handle = await open(databasePath, "wx", 384);
+    await handle.close();
+    databaseEntry = await lstat(databasePath);
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    databaseEntry = await lstat(databasePath);
+  }
+  if (databaseEntry.isSymbolicLink() || !databaseEntry.isFile()) {
+    throw new HarnessWorkspaceError(`The SQLite state path must be a real file: ${databasePath}.`);
+  }
+  const database = new SqliteDatabase(databasePath, { create: false, strict: true });
+  let closed = false;
+  const closeDatabase = () => {
+    if (!closed) {
+      closed = true;
+      database.close(false);
+    }
+  };
+  try {
+    const openedEntry = await lstat(databasePath);
+    if (openedEntry.isSymbolicLink() || !openedEntry.isFile() || openedEntry.dev !== databaseEntry.dev || openedEntry.ino !== databaseEntry.ino) {
+      throw new HarnessWorkspaceError(`The SQLite state path changed while it was being opened: ${databasePath}.`);
+    }
+    database.exec("PRAGMA journal_mode = WAL");
+    database.exec("PRAGMA busy_timeout = 5000");
+    database.exec("PRAGMA foreign_keys = ON");
+    await chmod(databasePath, 384);
+    const databaseLike = sqliteAdapter(database);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
+    const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
+    return {
+      backend: "sqlite",
+      store,
+      memory,
+      databasePath,
+      migration,
+      close: closeDatabase
+    };
+  } catch (error) {
+    closeDatabase();
+    throw error;
+  }
+};
+
+export { workspaceCheckpointSchema, workspaceRestoreOperationSchema, openWorkspaceCheckpointStore, withRuntimeInstruction, withFreshSystemInstructions, effectiveRuntimeBudget, createRuntimeBudget, runtimeManifest, childRuntimeSafety, createCheckpointTokenCap, createRepairProgress, createRepairController, RUNTIME_DIAGNOSTICS_KEY, runtimeCheckpointStore, tokenUsageCheckpointStore, HARNESS_SQLITE_FILE, HARNESS_OPERATIONS_SCHEMA_VERSION, TERMINAL_RUN_STATUSES, listHarnessRuns, inspectHarnessRun, cancelHarnessRun, cleanupHarnessRuns, sqliteAdapter, migrateLegacyFileRuns, openHarnessPersistence };