@zhivex-ai/harness 1.4.0 → 1.4.1

package/dist/{index-937cb7y8.js → index-02pqtbbg.js}

@@ -1,40 +1,64 @@
 import {
   openWorkspaceCheckpointStore
-} from "./index-6dft2vev.js";
+} from "./index-6599mpmy.js";
 import {
-  APPROVAL_HISTORY_KEY,
   appendUserMessage,
-  approvalDecisionViews,
-  approvalInputDigest,
   checkEvidence,
-  createPolicyDecisionEvidence,
   hostPolicyIdentity,
-  inspectHarnessPolicy,
+  initializeHarnessTaskBudget,
   issueExplicitReviewResponses,
   issueRecordedApprovalResponses,
-  observeHarnessPolicyDecisions,
-  readApprovalDecisions,
+  openHarnessTaskBudget,
+  persistHarnessTaskDraft,
+  readHarnessTaskDraft,
+  readTaskContinuityEvidence,
   requiresExplicitHostReview,
-  runHarness
-} from "./index-pp474137.js";
+  reviseHarnessTaskAcceptance,
+  runHarness,
+  runHarnessTask
+} from "./index-0zs2dz26.js";
 import {
   ASSISTANT_RESPONSE_KEY,
-  SESSION_RUN_STATUSES,
-  USAGE_LEDGER_KEY,
+  TASK_SOURCE_KEY,
   assistantResponses,
   cancelHarnessRun,
+  captureTaskSources
+} from "./index-f6mqa5gk.js";
+import {
+  resolvePackageCheckCommand
+} from "./index-d9zkmhz3.js";
+import {
+  APPROVAL_HISTORY_KEY,
+  approvalDecisionViews,
+  approvalInputDigest,
+  createPolicyDecisionEvidence,
+  inspectHarnessPolicy,
+  observeHarnessPolicyDecisions,
+  readApprovalDecisions
+} from "./index-wm9xeq1n.js";
+import {
+  SESSION_RUN_STATUSES,
+  TASK_ACCEPTANCE_KEY,
+  TASK_BUDGET_KEY,
+  TaskBudget,
+  USAGE_LEDGER_KEY,
+  compileTaskAcceptanceContract,
+  inspectTaskBudgetSummary,
   inspectUsageLedger,
-  openCliSessionStore
-} from "./index-s2k2edts.js";
+  nextTaskAcceptanceLedger,
+  openCliSessionStore,
+  readTaskAcceptanceLedger
+} from "./index-zxg4ve4j.js";
 import {
   createEditProposal,
   editProposalInputSchema,
   fileDigestSchema
-} from "./index-m34q25jj.js";
+} from "./index-xdbkcccf.js";
 import {
   CLI_JSON_SCHEMA_VERSION,
-  harnessClientRequestSchema
-} from "./index-nmjdwd4p.js";
+  harnessClientRequestSchema,
+  harnessTaskProjectionSchema
+} from "./index-4gt045j0.js";
 import {
   HarnessStateConflictError,
   harnessErrorDocument,
@@ -125,16 +149,338 @@ var runResultDocument = (result, harness) => ({
   stateDirectory: harness.config.stateDirectory
 });
 
+// src/client/task-control-host.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash, randomUUID } from "node:crypto";
+var exec = promisify(execFile);
+var TASK_HUMAN_DECISION_KEY = "harnessClientHumanDecisionV1";
+var hash = (value) => "sha256:" + createHash("sha256").update(JSON.stringify(value)).digest("hex");
+var taskReviewIdentity = (p) => hash(p.task);
+async function taskHumanDecision(host, p) {
+  const state = await host.store.load(p.task.observedRunId, host.config.scope);
+  const raw = state?.metadata?.[TASK_HUMAN_DECISION_KEY];
+  if (!raw || raw.schemaVersion !== 1 || raw.kind !== "accepted" || raw.provenance !== "explicit_operator_review" || typeof raw.at !== "number")
+    return { status: "not_recorded", at: null, provenance: null };
+  return {
+    status: raw.runId === p.task.observedRunId && raw.contractDigest === p.task.contractDigest && raw.snapshotDigest === p.task.artifact.observedDigest && p.task.review.structure === "verified" ? "current" : "stale",
+    at: raw.at,
+    provenance: "explicit_operator_review"
+  };
+}
+async function visibleTaskFiles(host, paths) {
+  for (const file of paths) {
+    const result = await exec("git", ["--literal-pathspecs", "ls-files", "--error-unmatch", "-v", "-z", "--", file], { cwd: host.workspace.root, timeout: 1e4, maxBuffer: 65536 });
+    if (result.stdout !== "H " + file + "\x00")
+      throw new Error("TASK_FILES_UNAVAILABLE");
+  }
+}
+async function taskGitReview(host) {
+  const result = await host.workspace.gitDiff();
+  if ([result.status, result.diff, result.staged].some((r) => r.exitCode !== 0 || r.timedOut || r.stdout.length >= 20000))
+    throw new Error("TASK_DIFF_UNAVAILABLE");
+  const text = result.diff.stdout + result.staged.stdout;
+  if (Buffer.byteLength(text) > 128 * 1024)
+    throw new Error("TASK_DIFF_CAPACITY");
+  return { text, identity: hash([result.status.stdout, result.diff.stdout, result.staged.stdout]) };
+}
+async function prepareClientTask(host, brief) {
+  if (host.config.execution.backend !== "none" || host.config.orchestration.profiles.length || host.agent.subagents?.length)
+    throw new Error("TASK_HOST_UNSUPPORTED");
+  const clean = async () => {
+    const git = await host.workspace.gitDiff();
+    if ([git.status, git.diff, git.staged].some((r) => r.exitCode !== 0 || r.timedOut || r.stdout.trim()))
+      throw new Error("TASK_CLEAN_BASELINE_REQUIRED");
+  };
+  await clean();
+  const file = await host.workspace.readFile("package.json");
+  if (file.truncated)
+    throw new Error("TASK_MANIFEST_UNAVAILABLE");
+  const manifest = JSON.parse(file.content.replace(/^\d+: /gm, ""));
+  const requiredChecks = await Promise.all(brief.checks.map(async (script, index) => {
+    const expectedScript = manifest.scripts?.[script];
+    if (typeof expectedScript !== "string" || !expectedScript.trim() || expectedScript.length > 2000)
+      throw new Error("TASK_CHECK_UNAVAILABLE");
+    const resolved = await resolvePackageCheckCommand(host.workspace.root, manifest, script, expectedScript, host.config.allowedChecks);
+    return {
+      id: "check-" + (index + 1),
+      kind: "package-script",
+      script,
+      expectedScript,
+      command: resolved.command[0],
+      args: resolved.command.slice(1),
+      purpose: ("Check " + script + " for: " + brief.goal).slice(0, 500),
+      execution: { backend: "none", approval: "required" }
+    };
+  }));
+  const contract = compileTaskAcceptanceContract({
+    schemaVersion: 1,
+    taskId: randomUUID(),
+    allowedWritePaths: brief.paths,
+    protectedFiles: ["package.json"],
+    requiredChecks,
+    humanReview: [
+      { id: "operator", requirement: brief.goal, status: "pending" },
+      ...brief.constraints.map((requirement, index) => ({ id: "constraint-" + (index + 1), requirement, status: "pending" }))
+    ]
+  }).contract;
+  await visibleTaskFiles(host, contract.allowedWritePaths);
+  const baseline = {};
+  for (const path of contract.allowedWritePaths) {
+    const inspected = await host.workspace.inspectFile(path);
+    if (inspected.bytes > 65536 || (await host.workspace.readFile(path)).digest !== inspected.digest)
+      throw new Error("TASK_FILE_UNAVAILABLE");
+    baseline[path] = inspected.digest;
+  }
+  await clean();
+  await initializeHarnessTaskBudget(host, contract.taskId, brief.budget);
+  return { schemaVersion: 1, budgetVersion: 1, goal: brief.goal, constraints: brief.constraints, contract, baseline };
+}
+async function currentClientTask(host, runId, allowedRunIds) {
+  const state = await host.store.load(runId, host.config.scope);
+  const ledger = state && readTaskAcceptanceLedger(state);
+  if (!state || !ledger)
+    throw new Error("TASK_CONTRACT_UNAVAILABLE");
+  const taskId = ledger.revisions.at(-1).contract.taskId;
+  const evidence = await readTaskContinuityEvidence(host, taskId, { allowedRunIds });
+  const latest = evidence.report.runs.at(-1), current = evidence.report.currentContract;
+  if (!current || latest?.runId !== runId || latest.revision !== state.revision)
+    throw new Error("TASK_REVIEW_CHANGED");
+  return { state, ledger, evidence, current, taskId };
+}
+async function persistClientTaskPreparationFailure(host, state, contract) {
+  const account = await openHarnessTaskBudget(host, contract.taskId);
+  const before = await readTaskContinuityEvidence(host, contract.taskId);
+  const ledger = before.report.runs.at(-1)?.ledger ?? nextTaskAcceptanceLedger(undefined, contract);
+  if (ledger.revisions.at(-1).digest !== compileTaskAcceptanceContract(contract).digest)
+    throw new Error("TASK_REVIEW_CHANGED");
+  await account.run(state.runId, async () => {
+    await before.verify();
+    const summary = await account.summary();
+    await host.store.save({
+      ...state,
+      ...host.agent.harness ? { harness: host.agent.harness } : {},
+      metadata: {
+        ...state.metadata,
+        [TASK_ACCEPTANCE_KEY]: JSON.parse(JSON.stringify(ledger)),
+        [TASK_BUDGET_KEY]: JSON.parse(JSON.stringify(summary)),
+        [TASK_SOURCE_KEY]: captureTaskSources(state.metadata, state.messages)
+      }
+    }, { expectedRevision: 0 });
+  });
+}
+async function keepClientTask(host, runId, allowedRunIds, expected) {
+  const initial = await currentClientTask(host, runId, allowedRunIds);
+  const account = await openHarnessTaskBudget(host, initial.taskId);
+  const ownerId = randomUUID();
+  if (!await host.store.acquireLease(account.accountRunId, { ownerId, ttlMs: 30000 }, host.config.scope))
+    throw new Error("TASK_REVIEW_BUSY");
+  try {
+    const { state, evidence, current } = await currentClientTask(host, runId, allowedRunIds);
+    const latest = evidence.report.runs.at(-1);
+    if (state.revision !== expected.runRevision || current.digest !== expected.contractDigest || evidence.report.budget?.revision !== expected.budgetRevision || state.status !== "completed" || evidence.report.reasons.length || latest.checks.some((c) => c.status !== "confirmed") || latest.snapshot?.snapshotDigest !== expected.snapshotDigest || latest.delivery?.snapshotDigest !== expected.snapshotDigest)
+      throw new Error("TASK_REVIEW_CHANGED");
+    await visibleTaskFiles(host, current.contract.allowedWritePaths);
+    if ((await taskGitReview(host)).identity !== expected.gitIdentity)
+      throw new Error("TASK_REVIEW_CHANGED");
+    await evidence.verifyAll();
+    if (!await host.store.renewLease(account.accountRunId, { ownerId, ttlMs: 30000 }, host.config.scope))
+      throw new Error("TASK_REVIEW_BUSY");
+    const decision = {
+      schemaVersion: 1,
+      kind: "accepted",
+      runId,
+      contractDigest: current.digest,
+      contractRevision: current.revision,
+      snapshotDigest: expected.snapshotDigest,
+      reviewedRunRevision: expected.runRevision,
+      at: Date.now(),
+      provenance: "explicit_operator_review"
+    };
+    await host.store.save({ ...state, metadata: { ...state.metadata, [TASK_HUMAN_DECISION_KEY]: decision } }, { expectedRevision: state.revision });
+    return decision;
+  } finally {
+    await host.store.releaseLease(account.accountRunId, ownerId, host.config.scope);
+  }
+}
+
+// src/client/task-projection-host.ts
+import { createHash as createHash2 } from "node:crypto";
+import { createRedactionPolicy } from "@zhivex-ai/agents";
+class TaskProjectionFault extends Error {
+  causeCode;
+  constructor(causeCode) {
+    super(causeCode);
+    this.causeCode = causeCode;
+  }
+}
+var fault = (cause) => {
+  throw new TaskProjectionFault(cause);
+};
+var hash2 = (value) => "sha256:" + createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var sha = (value) => typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value) ? value : null;
+function redactTaskDisplayText(host, raw, sensitiveValues = []) {
+  const redaction = createRedactionPolicy({ includeEmails: true });
+  let safe = raw;
+  for (const secret of [host.workspace.root, ...sensitiveValues])
+    if (secret)
+      safe = safe.split(secret).join("[REDACTED]");
+  safe = redaction.redactText(safe).replace(/\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]+/gi, "[REDACTED]").replace(/(^|[^A-Za-z0-9_./\\-])(?:\/(?!\/)|[A-Za-z]:[\\/]|\\\\)[^\s"'`<>\[\](){}]*/g, "$1[REDACTED_PATH]").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+  return safe;
+}
+async function projectHarnessTask(host, request, allowedRunIds, sensitiveValues = []) {
+  try {
+    if (host.config.execution.backend !== "none" || host.config.orchestration.profiles.length || host.agent.subagents?.length)
+      return fault("UNSUPPORTED_HOST");
+    if (!allowedRunIds.includes(request.runId))
+      return fault("OUT_OF_SCOPE");
+    let state = await host.store.load(request.runId, host.config.scope);
+    if (!state)
+      return fault("EVIDENCE_UNAVAILABLE");
+    const requestedState = state;
+    let sourceRunId = request.runId;
+    const prior = state.metadata?.clientTaskPriorRunV1;
+    if (!readTaskAcceptanceLedger(state) && typeof prior === "string" && ["failed", "cancelled"].includes(state.status) && !state.steps.length && !state.toolResults.length && !state.pendingApprovals.length) {
+      if (prior === request.runId || !allowedRunIds.includes(prior))
+        return fault("OUT_OF_SCOPE");
+      const retained = await host.store.load(prior, host.config.scope);
+      if (!retained)
+        return fault("EVIDENCE_UNAVAILABLE");
+      state = retained;
+      sourceRunId = prior;
+    }
+    const ledger = readTaskAcceptanceLedger(state);
+    if (!ledger)
+      return fault("CONTRACT_UNAVAILABLE");
+    const taskId = ledger.revisions.at(-1).contract.taskId;
+    const rawBudget = state.metadata?.[TASK_BUDGET_KEY];
+    const accountId = TaskBudget.accountId(host.config.scope, taskId);
+    if (rawBudget === undefined && await host.store.load(accountId, host.config.scope))
+      return fault("EVIDENCE_UNAVAILABLE");
+    const binding = inspectTaskBudgetSummary(rawBudget);
+    if (rawBudget !== undefined && (!binding || binding.taskId !== taskId))
+      return fault("EVIDENCE_UNAVAILABLE");
+    const evidence = await readTaskContinuityEvidence(host, taskId, {
+      allowedRunIds,
+      ...rawBudget === undefined ? { legacyRunId: request.runId } : {}
+    });
+    const report = evidence.report, latest = report.runs.at(-1), current = report.currentContract;
+    if (report.reasons.some((reason) => ["TASK_CONTINUITY_RUN_MISSING", "TASK_CONTINUITY_SOURCE_INVALID"].includes(reason)))
+      return fault("EVIDENCE_UNAVAILABLE");
+    if (sourceRunId !== request.runId && (!report.budget || report.budget.runs.includes(request.runId)))
+      return fault("EVIDENCE_UNAVAILABLE");
+    if (!latest || !current || !report.runs.some((run) => run.runId === sourceRunId))
+      return fault("EVIDENCE_UNAVAILABLE");
+    if (binding && (binding.accountRunId !== report.budget?.accountRunId || binding.coordinatorId !== report.budget?.coordinatorId))
+      return fault("EVIDENCE_UNAVAILABLE");
+    let textTruncated = false;
+    const text = (raw) => {
+      const safe = redactTaskDisplayText(host, raw, sensitiveValues);
+      if (safe.length > 2048) {
+        textTruncated = true;
+        return safe.slice(0, 2047) + "…";
+      }
+      return safe;
+    };
+    const delivery = object(latest.delivery);
+    const deliveredDigest = sha(delivery.snapshotDigest);
+    const observedDigest = latest.snapshot?.snapshotDigest ?? null;
+    const correspondence = observedDigest && deliveredDigest && latest.snapshot && delivery.runId === latest.runId && delivery.executionIdentity === latest.snapshot.executionIdentity && delivery.patchId === latest.snapshot.patchId ? observedDigest === deliveredDigest ? "current" : "stale" : deliveredDigest ? "stale" : "missing";
+    const effects = report.runs.flatMap((run) => run.effects);
+    const missingEvidence = report.reasons.some((reason) => /EFFECT_(?:EVIDENCE_MISSING|UNCERTAIN)/.test(reason));
+    const budget = report.budget;
+    const reasons = [...report.reasons];
+    if (budget && Object.values(budget.remaining).some((value) => value === 0))
+      reasons.push("TASK_BUDGET_EXHAUSTED");
+    const blocked = reasons.length > 0;
+    const execution = ["created", "queued", "running", "waiting_approval", "cancel_requested", "completed", "failed", "cancelled", "timed_out"].find((status) => status === latest.status) ?? "unknown";
+    const structure = execution === "completed" && correspondence === "current" && latest.hostPolicyCompatible && latest.checks.every((check) => check.status === "confirmed") && !missingEvidence ? "verified" : "incomplete";
+    const task = {
+      reference: hash2(["task", taskId]),
+      contractRevision: current.revision,
+      contractDigest: current.digest,
+      runRevision: latest.revision ?? 0,
+      objective: latest.objective === null ? null : text(latest.objective),
+      objectiveSource: latest.objective === null ? "unavailable" : latest.briefStatus === "current" ? "operator_brief" : "retained_operator_source",
+      observedRunId: latest.runId,
+      historicalRequest: latest.runId !== request.runId,
+      execution,
+      artifact: { observedDigest, deliveredDigest, correspondence, paths: current.contract.allowedWritePaths.map(text), contents: "not_included" },
+      review: {
+        structure,
+        semantic: "pending",
+        acceptance: "not_recorded",
+        human: current.contract.humanReview.map((row) => ({ id: text(row.id), requirement: text(row.requirement), status: "pending" })),
+        checks: latest.checks.map((check) => ({ id: text(check.id), status: check.status, provenance: "contract_snapshot_and_tool_journal" }))
+      },
+      budget: {
+        availability: budget ? "authoritative" : "legacy_not_enabled",
+        revision: budget?.revision ?? null,
+        confirmed: budget?.confirmed ?? null,
+        reserved: budget?.reserved ?? null,
+        unknown: budget?.unknown ?? null,
+        remaining: budget?.remaining ?? null,
+        limits: budget?.limits ?? null,
+        estimated: null,
+        estimation: "not_separately_recorded",
+        usageComplete: budget?.usageComplete ?? null,
+        admissionsClosed: budget?.admissionsClosed ?? null,
+        monetary: { estimatedConfirmedUsd: budget?.monetaryDetails.estimatedConfirmedUsd ?? null, reservedUsd: budget?.monetaryDetails.reservedUsd ?? null, unknownHeldUsd: budget?.monetaryDetails.unknownHeldUsd ?? null, remainingUsd: budget?.monetaryDetails.remainingUsd ?? null, unknown: !budget || !budget.monetaryDetails.costComplete, costKind: "estimate-not-invoice" }
+      },
+      effects: {
+        readOnly: effects.filter((row) => row.status === "read_only").length,
+        recorded: effects.filter((row) => row.status === "recorded").length,
+        unknown: effects.filter((row) => row.status === "unknown").length,
+        missingEvidence,
+        automaticReplay: false,
+        providerStopped: "unconfirmed"
+      },
+      nextAction: {
+        kind: blocked ? "reconcile" : ["created", "queued", "running", "cancel_requested"].includes(execution) ? "wait" : execution === "waiting_approval" ? "review_approval" : structure === "verified" ? "review_delivery" : "explicit_continuation",
+        permitted: "read_only",
+        authorization: "required_for_execution",
+        preserves: "contract_receipts_budget_and_effects",
+        automaticReplay: false
+      },
+      diagnostic: execution === "failed" ? { code: "EXECUTION_FAILED", cause: "execution_terminal_failure", impact: "acceptance_not_established", safeAction: missingEvidence ? "reconcile" : "review_configuration" } : execution === "cancelled" ? { code: "EXECUTION_CANCELLED", cause: "operator_or_runtime_cancellation", impact: "acceptance_not_established", safeAction: "reconcile" } : execution === "timed_out" ? { code: "EXECUTION_TIMED_OUT", cause: "execution_deadline", impact: "acceptance_not_established", safeAction: "reconcile" } : structure !== "verified" ? { code: "EVIDENCE_INCOMPLETE", cause: "receipts_missing_or_stale", impact: "acceptance_not_established", safeAction: "review_delivery" } : null,
+      reasons,
+      provenance: "host_durable_contract_journal_budget_and_fresh_native_snapshot",
+      textTruncated
+    };
+    await evidence.verifyAll();
+    if (rawBudget === undefined && await host.store.load(accountId, host.config.scope))
+      return fault("SNAPSHOT_CHANGED");
+    if (JSON.stringify(await host.store.load(request.runId, host.config.scope)) !== JSON.stringify(requestedState))
+      return fault("SNAPSHOT_CHANGED");
+    const projection = { schemaVersion: 1, ...request, task };
+    if (Buffer.byteLength(JSON.stringify(projection)) > 64 * 1024)
+      return fault("PAYLOAD_LIMIT");
+    return harnessTaskProjectionSchema.parse(projection);
+  } catch (error) {
+    if (error instanceof TaskProjectionFault)
+      throw error;
+    const code = error instanceof Error ? error.message.split(":")[0] : "";
+    if (code === "TASK_PROJECTION_SCOPE_MISMATCH")
+      return fault("OUT_OF_SCOPE");
+    if (code === "TASK_CONTINUITY_CHANGED")
+      return fault("SNAPSHOT_CHANGED");
+    if (code === "TASK_CONTINUITY_CAPACITY" || code === "TASK_ACCEPTANCE_HISTORY_CAPACITY")
+      return fault("PAYLOAD_LIMIT");
+    return fault("EVIDENCE_UNAVAILABLE");
+  }
+}
+
 // src/approvals/approval-diff.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { z } from "zod";
 var APPROVAL_DIFFS_KEY = "clientApprovalDiffsV1";
-var sha = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-var file = z.object({ path: z.string().max(1024), expectedDigest: sha.nullable(), before: z.string().nullable(), after: z.string().nullable(), afterDigest: sha.nullable(), beforeMode: z.number().int().optional(), afterMode: z.number().int().optional(), operation: z.enum(["create", "update", "delete"]).optional() }).strict();
-var archive = z.object({ approvalId: z.string().max(256), digest: z.string().regex(/^[a-f0-9]{64}$/), proposalId: sha, files: z.array(file).min(1).max(50) }).strict();
+var sha2 = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+var file = z.object({ path: z.string().max(1024), expectedDigest: sha2.nullable(), before: z.string().nullable(), after: z.string().nullable(), afterDigest: sha2.nullable(), beforeMode: z.number().int().optional(), afterMode: z.number().int().optional(), operation: z.enum(["create", "update", "delete"]).optional() }).strict();
+var archive = z.object({ approvalId: z.string().max(256), digest: z.string().regex(/^[a-f0-9]{64}$/), proposalId: sha2, files: z.array(file).min(1).max(50) }).strict();
 var archives = z.array(archive).max(512);
 var maxBytes = 2 * 1024 * 1024;
-var contentDigest = (content) => content === null ? null : `sha256:${createHash("sha256").update(content).digest("hex")}`;
+var contentDigest = (content) => content === null ? null : `sha256:${createHash3("sha256").update(content).digest("hex")}`;
 function read(state) {
   const value = state.metadata?.[APPROVAL_DIFFS_KEY] ?? [];
   if (Buffer.byteLength(JSON.stringify(value)) > maxBytes)
@@ -221,7 +567,7 @@ async function attachApprovalPreviews(run, workspace, options = {}) {
 }
 
 // src/client/adapter.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 var canonical = (value) => {
   if (Array.isArray(value))
     return `[${value.map(canonical).join(",")}]`;
@@ -229,7 +575,7 @@ var canonical = (value) => {
     return `{${Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
   return JSON.stringify(value) ?? "null";
 };
-var digest = (value) => createHash2("sha256").update(canonical(value)).digest("hex");
+var digest = (value) => createHash4("sha256").update(canonical(value)).digest("hex");
 
 class ClientFault extends Error {
   code;
@@ -281,7 +627,7 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
     scope: harness.config.scope
   });
   const projectId = `project_${digest([sessions.workspaceKey, sessions.scopeKey])}`;
-  const connectionId = `connection_${randomUUID()}`;
+  const connectionId = `connection_${randomUUID2()}`;
   let checkpoints;
   const checkpointStore = async () => checkpoints ??= await openWorkspaceCheckpointStore(harness.workspace, sessions);
   const restoreDocument = async (operation) => {
@@ -298,8 +644,12 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
     }, preview };
   };
   let closed = false, busy = false;
+  let taskSequence = 0;
+  const taskReviews = new Map;
+  const taskProjection = (s, runId) => projectHarnessTask(harness, { connectionId, projectId, sessionId: s.sessionId, runId, sequence: ++taskSequence }, s.runs.map((r) => r.runId), options.taskProjectionSensitiveValues);
+  const safeTaskDiff = (raw) => redactTaskDisplayText(harness, raw, options.taskProjectionSensitiveValues);
   let active;
-  const invoke = async (sessionId, input, prompt) => {
+  const invoke = async (sessionId, input, prompt, taskOptions) => {
     const runId = "state" in input ? input.state.runId : input.runId;
     let settle;
     const settled = new Promise((resolve) => {
@@ -308,6 +658,7 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
     const controller = new AbortController;
     active = { sessionId, runId, controller, settled };
     let prepared;
+    let invocationStarted = false;
     try {
       if (prompt !== undefined)
         await options.onPrompt?.(sessionId, runId, prompt);
@@ -321,10 +672,12 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
       active.runtime = runtime;
       const mutationOffset = runtime.workspace.mutationAudit().length;
       const policyEvidence = createPolicyDecisionEvidence();
+      invocationStarted = true;
       const result = await observeHarnessPolicyDecisions(async (event) => {
         policyEvidence.append(event);
         await options.onPolicyDecision?.(sessionId, runId, event);
-      }, () => runHarness(runtime, { ...input, abortSignal: controller.signal }, {
+      }, () => (taskOptions ? runHarnessTask : runHarness)(runtime, { ...input, abortSignal: controller.signal }, {
+        ...taskOptions,
         onEvent: (event) => options.onEvent?.(sessionId, runId, event)
       }));
       const document = { ...runResultDocument(result, runtime), policyEvidence: policyEvidence.snapshot(), mutations: runtime.workspace.mutationAudit().slice(mutationOffset) };
@@ -341,7 +694,7 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
         persisted = await harness.store.load(runId, harness.config.scope);
         if (!persisted && !("state" in input)) {
           const now = Date.now();
-          await harness.store.save({
+          const fallback = {
             schemaVersion: 1,
             revision: 0,
             runId,
@@ -358,8 +711,21 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
             pendingApprovals: [],
             startedAt: now,
             updatedAt: now,
-            error: { message: "Run stopped before initialization." }
-          });
+            error: { message: "Run stopped before initialization." },
+            metadata: input.metadata ?? {}
+          };
+          if (taskOptions?.taskAdmissionReview && taskOptions.taskAcceptance) {
+            const budget = await (await openHarnessTaskBudget(harness, taskOptions.taskAcceptance.taskId)).summary();
+            if (budget.runs.includes(runId))
+              throw new Error("TASK_ADMISSION_STATE_UNAVAILABLE");
+            await harness.store.save({ ...fallback, metadata: {
+              ...fallback.metadata,
+              clientTaskPriorRunV1: taskOptions.taskAdmissionReview.runId
+            } }, { expectedRevision: 0 });
+          } else if (!invocationStarted && taskOptions?.taskAcceptance)
+            await persistClientTaskPreparationFailure(harness, fallback, taskOptions.taskAcceptance);
+          else
+            await harness.store.save(fallback);
           persisted = await harness.store.load(runId, harness.config.scope);
         }
       } catch {}
@@ -423,6 +789,135 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
     let s = await refresh(await getSession(c.sessionId));
     if (c.method === "session.get")
       return { kind: "session", session: sessionDocument(s) };
+    if (c.method === "task.review") {
+      const projection = await taskProjection(s, c.runId);
+      const detail = await currentClientTask(harness, c.runId, s.runs.map((r) => r.runId));
+      const git = await taskGitReview(harness);
+      await detail.evidence.verifyAll();
+      const terminal = ["completed", "failed", "cancelled", "timed_out"].includes(projection.task.execution);
+      const blockers = projection.task.reasons.filter((r) => r !== "TASK_BUDGET_CANCELLED");
+      const canContinue = terminal && !blockers.length && projection.task.budget.availability === "authoritative" && projection.task.budget.usageComplete === true;
+      const diff = safeTaskDiff(git.text);
+      const complete = diff === git.text && !projection.task.textTruncated && detail.current.contract.humanReview.every((h) => safeTaskDiff(h.requirement) === h.requirement);
+      const canKeep = canContinue && complete && projection.task.review.structure === "verified";
+      const canRevise = terminal && !blockers.length && detail.current.contract.humanReview.length < 9;
+      const now = (options.now ?? Date.now)();
+      for (const [id, review] of taskReviews)
+        if (review.expiresAt <= now)
+          taskReviews.delete(id);
+      if (taskReviews.size >= 128)
+        return fail("CAPACITY_EXCEEDED");
+      const reviewId = randomUUID2(), expiresAt = now + 300000;
+      taskReviews.set(reviewId, {
+        sessionId: s.sessionId,
+        runId: c.runId,
+        expiresAt,
+        identity: taskReviewIdentity(projection),
+        gitIdentity: git.identity,
+        projection,
+        canKeep,
+        canContinue,
+        canRevise
+      });
+      return { kind: "taskReview", review: {
+        reviewId,
+        expiresAt,
+        projection,
+        diff,
+        complete,
+        canKeep,
+        canContinue,
+        canRevise,
+        humanDecision: await taskHumanDecision(harness, projection)
+      } };
+    }
+    if (c.method === "task.keep" || c.method === "task.revise" || c.method === "task.continue") {
+      const review = taskReviews.get(c.reviewId);
+      taskReviews.delete(c.reviewId);
+      if (!review || review.sessionId !== s.sessionId || review.runId !== c.runId || review.expiresAt <= (options.now ?? Date.now)())
+        return fail("REVISION_CONFLICT");
+      const projection = await taskProjection(s, c.runId);
+      if (taskReviewIdentity(projection) !== review.identity || (await taskGitReview(harness)).identity !== review.gitIdentity)
+        return fail("REVISION_CONFLICT");
+      const detail = await currentClientTask(harness, c.runId, s.runs.map((r) => r.runId));
+      if (c.method === "task.keep") {
+        if (!review.canKeep || !projection.task.artifact.observedDigest || projection.task.budget.revision === null)
+          return fail("INVALID_STATE");
+        await keepClientTask(harness, c.runId, s.runs.map((r) => r.runId), {
+          runRevision: projection.task.runRevision,
+          contractDigest: projection.task.contractDigest,
+          snapshotDigest: projection.task.artifact.observedDigest,
+          budgetRevision: projection.task.budget.revision,
+          gitIdentity: review.gitIdentity
+        });
+      } else if (c.method === "task.revise") {
+        if (!review.canRevise)
+          return fail("INVALID_STATE");
+        await reviseHarnessTaskAcceptance(harness, {
+          runId: c.runId,
+          expectedRunRevision: projection.task.runRevision,
+          expectedContractRevision: projection.task.contractRevision,
+          contract: {
+            ...detail.current.contract,
+            humanReview: [...detail.current.contract.humanReview, { id: "correction-" + randomUUID2(), requirement: c.correction, status: "pending" }]
+          }
+        });
+      } else {
+        if (!review.canContinue)
+          return fail("INVALID_STATE");
+        const runId = "run_" + randomUUID2();
+        s = await sessions.appendRun(s.sessionId, { runId, provider: harness.config.provider, model: harness.config.model, status: "created" }, { expectedRevision: s.revision });
+        const contract = detail.current.contract;
+        const brief = {
+          schemaVersion: 1,
+          budgetVersion: 1,
+          goal: contract.humanReview.find((h) => h.id === "operator")?.requirement ?? projection.task.objective ?? "Retained task",
+          constraints: contract.humanReview.filter((h) => h.id !== "operator").map((h) => h.requirement),
+          contract,
+          baseline: {}
+        };
+        const result = await invoke(s.sessionId, {
+          runId,
+          scope: harness.config.scope,
+          metadata: { zhivexCodeTaskV1: JSON.parse(JSON.stringify(brief)) },
+          messages: appendUserMessage(terminalContinuationMessages(detail.state.messages), c.prompt)
+        }, c.prompt, {
+          taskAcceptance: contract,
+          taskBudgetExisting: true,
+          taskBudgetContinue: true,
+          taskAdmissionReview: {
+            runId: c.runId,
+            runRevision: projection.task.runRevision,
+            contractDigest: projection.task.contractDigest,
+            snapshotDigest: projection.task.artifact.observedDigest,
+            budgetRevision: projection.task.budget.revision
+          }
+        });
+        s = await sessions.updateRun(s.sessionId, runId, { status: sessionStatus(result.state.status) });
+        return { kind: "run", session: sessionDocument(s), run: await documentRun(result.state) };
+      }
+      const updated = await taskProjection(s, c.runId);
+      return { kind: "task", projection: updated, humanDecision: await taskHumanDecision(harness, updated) };
+    }
+    if (c.method === "task.start") {
+      if (s.revision !== c.expectedRevision || s.runs.length)
+        return fail("REVISION_CONFLICT");
+      const brief = await prepareClientTask(harness, c.brief);
+      await persistHarnessTaskDraft(harness, s.sessionId, brief);
+      const runId = "run_" + randomUUID2();
+      s = await sessions.appendRun(s.sessionId, { runId, provider: harness.config.provider, model: harness.config.model, status: "created" }, { expectedRevision: s.revision });
+      const prompt = "Operator goal: " + brief.goal + `
+Constraints: ` + brief.constraints.join("; ") + `
+Exact editable files: ` + brief.contract.allowedWritePaths.join(", ") + ". Execute every declared check after the final edit. Passing checks still require human acceptance.";
+      const result = await invoke(s.sessionId, {
+        runId,
+        scope: harness.config.scope,
+        metadata: { zhivexCodeTaskV1: JSON.parse(JSON.stringify(brief)) },
+        messages: appendUserMessage([], prompt)
+      }, brief.goal, { taskAcceptance: brief.contract, taskBudgetExisting: true });
+      s = await sessions.updateRun(s.sessionId, runId, { status: sessionStatus(result.state.status) });
+      return { kind: "run", session: sessionDocument(s), run: await documentRun(result.state) };
+    }
     if (c.method === "checkpoint.list") {
       const store = await checkpointStore();
       return { kind: "checkpoints", checkpoints: store.listCheckpoints(s.sessionId), restores: store.listRestores(s.sessionId) };
@@ -468,9 +963,11 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
         return { kind: "session", session: sessionDocument(await sessions.rename(s.sessionId, c.title, { expectedRevision: c.expectedRevision })) };
       const last = s.runs.at(-1);
       const previous = last ? await getRun(s, last.runId) : undefined;
+      if (previous && readTaskAcceptanceLedger(previous) || await readHarnessTaskDraft(harness.store, harness.config.scope, s.sessionId))
+        return fail("INVALID_STATE");
       if (previous && !["completed", "failed", "cancelled", "timed_out"].includes(previous.status))
         return fail("INVALID_STATE");
-      const runId = `run_${randomUUID()}`;
+      const runId = `run_${randomUUID2()}`;
       s = await sessions.appendRun(s.sessionId, { runId, provider: harness.config.provider, model: harness.config.model, status: "created" }, { expectedRevision: c.expectedRevision });
       const result = await invoke(s.sessionId, {
         runId,
@@ -488,7 +985,7 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
       return fail("REVISION_CONFLICT");
     if (c.method === "run.cancel") {
       if (["created", "running", "queued", "cancel_requested"].includes(state.status)) {
-        const ownerId = `cancel_${randomUUID()}`;
+        const ownerId = `cancel_${randomUUID2()}`;
         if (!harness.store.acquireLease || !harness.store.releaseLease)
           return fail("INVALID_STATE");
         if (!await harness.store.acquireLease(state.runId, { ownerId, ttlMs: 30000 }, harness.config.scope))
@@ -607,7 +1104,7 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
         return { ok: false, error: { code: "CONNECTION_EXPIRED" } };
       if (!versions.includes(1))
         return { ok: false, error: { code: "VERSION_UNSUPPORTED" } };
-      return { ok: true, protocolVersion: 1, connectionId, projectId, capabilities: ["project.get", "policy.get", "session.list", "session.create", "session.get", "session.rename", "run.start", "run.get", "approval.resolve", "run.cancel.checkpoint", "run.cancel.active", "idempotency.connection", "revision.precondition", "checkpoint.list", "checkpoint.inspect", "checkpoint.capture", "restore.prepare", "restore.get", "restore.apply", "restore.recoverFork"] };
+      return { ok: true, protocolVersion: 1, connectionId, projectId, capabilities: ["task.control.v1", "task.start", "task.review", "task.keep", "task.revise", "task.continue", "task.get", "task.projection.v1", "project.get", "policy.get", "session.list", "session.create", "session.get", "session.rename", "run.start", "run.get", "approval.resolve", "run.cancel.checkpoint", "run.cancel.active", "idempotency.connection", "revision.precondition", "checkpoint.list", "checkpoint.inspect", "checkpoint.capture", "restore.prepare", "restore.get", "restore.apply", "restore.recoverFork"] };
     },
     async dispatch(value) {
       const hostReviewed = Boolean(value && typeof value === "object" && reviewedRequests.delete(value));
@@ -622,8 +1119,36 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
       if (closed || request.connectionId !== connectionId)
         return error("CONNECTION_EXPIRED");
       const c = request.command;
+      if (c.method === "task.get" && !hostReviewed) {
+        const sequence = ++taskSequence;
+        try {
+          if (c.projectId !== projectId)
+            throw new TaskProjectionFault("OUT_OF_SCOPE");
+          if (c.projectionVersion !== 1)
+            throw new TaskProjectionFault("UNSUPPORTED_VERSION");
+          if (!Number.isSafeInteger(sequence))
+            throw new TaskProjectionFault("PAYLOAD_LIMIT");
+          const session = await sessions.get(c.sessionId);
+          if (!session || session.archivedAt || session.deletedAt || !session.runs.some((run) => run.runId === c.runId))
+            throw new TaskProjectionFault("OUT_OF_SCOPE");
+          const projection = await projectHarnessTask(harness, { connectionId, projectId, sessionId: c.sessionId, runId: c.runId, sequence }, session.runs.map((run) => run.runId), options.taskProjectionSensitiveValues);
+          if (JSON.stringify(await sessions.get(c.sessionId)) !== JSON.stringify(session))
+            throw new TaskProjectionFault("SNAPSHOT_CHANGED");
+          return { protocolVersion: 1, requestId: request.requestId, ok: true, data: { kind: "task", projection, humanDecision: await taskHumanDecision(harness, projection) } };
+        } catch (cause) {
+          const finite = cause instanceof TaskProjectionFault ? cause.causeCode : "EVIDENCE_UNAVAILABLE";
+          const code = finite === "OUT_OF_SCOPE" ? "NOT_FOUND" : finite === "UNSUPPORTED_VERSION" ? "VERSION_UNSUPPORTED" : finite === "SNAPSHOT_CHANGED" ? "REVISION_CONFLICT" : finite === "PAYLOAD_LIMIT" ? "CAPACITY_EXCEEDED" : "INVALID_STATE";
+          return { protocolVersion: 1, requestId: request.requestId, ok: false, error: { code, taskDiagnostic: {
+            cause: finite,
+            impact: "projection_unavailable",
+            safeAction: finite === "SNAPSHOT_CHANGED" ? "retry_read" : ["UNSUPPORTED_VERSION", "UNSUPPORTED_HOST", "OUT_OF_SCOPE", "CONTRACT_UNAVAILABLE", "PAYLOAD_LIMIT"].includes(finite) ? "review_configuration" : "reconcile"
+          } } };
+        }
+      }
       if (hostReviewed && c.method !== "approval.resolve")
         return error("INVALID_REQUEST");
+      if (c.method === "task.get")
+        return error("INVALID_REQUEST");
       const key = "idempotencyKey" in c ? c.idempotencyKey : undefined;
       const fingerprint = digest({ command: c, hostReviewed });
       const existing = key ? receipts.get(key) : undefined;
@@ -697,6 +1222,7 @@ var createHarnessClientAdapter = async (harness, options = {}) => {
       checkpoints?.close();
       sessions.close();
       receipts.clear();
+      taskReviews.clear();
     }
   };
   return adapter;