@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/{service-client-cli-fn54ev6w.js → service-client-cli-v6qptg9x.js}

@@ -1,23 +1,25 @@
 import {
   ActivityHistory,
-  CLI_EVENT_SCHEMA_VERSION,
-  CLI_JSON_SCHEMA_VERSION,
   ConsoleInput,
   ToolActivity,
-  changeEnvelopeSchema,
   formatAppliedFiles,
   formatConsoleHelp,
   formatConsoleWelcome,
   formatPolicyDecision,
-  harnessPolicyDecisionEventSchema,
   navigateConsole,
   printPolicyInspection,
-  sanitizeTerminalText,
+  sanitizeTerminalText
+} from "./cli-entry-h2yc9x37.js";
+import {
+  CLI_EVENT_SCHEMA_VERSION,
+  CLI_JSON_SCHEMA_VERSION,
+  changeEnvelopeSchema,
+  harnessPolicyDecisionEventSchema,
   serializeStreamResult
-} from "./cli-entry-4ngptr62.js";
+} from "./cli-entry-928p8h41.js";
 import {
   HARNESS_VERSION
-} from "./cli-entry-w0hterjs.js";
+} from "./cli-entry-q8bgkn9m.js";
 import {
   HARNESS_ERROR_CODES,
   HARNESS_ERROR_SCHEMA_VERSION,
@@ -25,7 +27,7 @@ import {
   HarnessStateConflictError,
   PROVIDERS,
   reasoningEffortSchema
-} from "./cli-entry-20w6nh0k.js";
+} from "./cli-entry-hdtfef27.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -38,7 +40,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { createServer, request as httpRequest } from "node:http";
 import { mkdir, lstat, realpath, open, unlink, chmod } from "node:fs/promises";
 import path from "node:path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/client/protocol.ts
 import { z } from "zod";
@@ -80,6 +82,24 @@ var harnessClientCommandSchema = z.discriminatedUnion("method", [
   z.object({ method: z.literal("restore.apply"), ...restore, ...mutation, expectedRevision: revision, reviewedProposalId: fileDigest }).strict(),
   z.object({ method: z.literal("restore.recoverFork"), ...restore, ...mutation, expectedRevision: revision, forkSessionId: id }).strict(),
   z.object({ method: z.literal("run.start"), ...session, ...mutation, expectedRevision: revision, prompt: z.string().min(1).max(64 * 1024) }).strict(),
+  z.object({
+    method: z.literal("task.start"),
+    ...session,
+    ...mutation,
+    expectedRevision: revision,
+    brief: z.strictObject({
+      goal: z.string().trim().min(1).max(2000),
+      paths: z.array(z.string().min(1).max(1024)).min(1).max(20),
+      checks: z.array(id).min(1).max(8),
+      constraints: z.array(z.string().trim().min(1).max(500)).max(8),
+      budget: z.strictObject({ inputTokens: z.number().int().positive().safe(), outputTokens: z.number().int().positive().safe(), totalTokens: z.number().int().positive().safe() })
+    })
+  }).strict(),
+  z.object({ method: z.literal("task.review"), ...run }).strict(),
+  z.object({ method: z.literal("task.keep"), ...run, ...mutation, reviewId: z.string().uuid() }).strict(),
+  z.object({ method: z.literal("task.revise"), ...run, ...mutation, reviewId: z.string().uuid(), correction: z.string().trim().min(1).max(500) }).strict(),
+  z.object({ method: z.literal("task.continue"), ...run, ...mutation, reviewId: z.string().uuid(), prompt: z.string().trim().min(1).max(2000) }).strict(),
+  z.object({ method: z.literal("task.get"), ...run, projectionVersion: z.number().int().nonnegative().safe() }).strict(),
   z.object({ method: z.literal("run.get"), ...run, includeReview: z.boolean().optional(), includeDiff: z.boolean().optional(), decisionOffset: z.number().int().min(0).max(512).optional() }).strict(),
   z.object({
     method: z.literal("approval.resolve"),
@@ -97,19 +117,94 @@ var harnessClientRequestSchema = z.object({
   command: harnessClientCommandSchema
 }).strict();
 
-// src/approvals/approval-diff.ts
+// src/client/task-control-host.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+
+// src/client/task-projection-host.ts
+import { createRedactionPolicy } from "@zhivex-ai/agents";
+
+// src/client/task-projection.ts
 import { z as z2 } from "zod";
-var sha = z2.string().regex(/^sha256:[a-f0-9]{64}$/);
-var file = z2.object({ path: z2.string().max(1024), expectedDigest: sha.nullable(), before: z2.string().nullable(), after: z2.string().nullable(), afterDigest: sha.nullable(), beforeMode: z2.number().int().optional(), afterMode: z2.number().int().optional(), operation: z2.enum(["create", "update", "delete"]).optional() }).strict();
-var archive = z2.object({ approvalId: z2.string().max(256), digest: z2.string().regex(/^[a-f0-9]{64}$/), proposalId: sha, files: z2.array(file).min(1).max(50) }).strict();
-var archives = z2.array(archive).max(512);
+var id2 = z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var count = z2.number().int().nonnegative().safe();
+var digest = z2.string().regex(/^sha256:[a-f0-9]{64}$/);
+var text = z2.string().max(2048);
+var tokens = z2.strictObject({ inputTokens: count, outputTokens: count, totalTokens: count });
+var harnessTaskProjectionSchema = z2.strictObject({
+  schemaVersion: z2.literal(1),
+  connectionId: id2,
+  sequence: count,
+  projectId: id2,
+  sessionId: id2,
+  runId: id2,
+  task: z2.strictObject({
+    reference: digest,
+    contractRevision: count,
+    contractDigest: digest,
+    runRevision: count,
+    objective: text.nullable(),
+    objectiveSource: z2.enum(["operator_brief", "retained_operator_source", "unavailable"]),
+    observedRunId: id2,
+    historicalRequest: z2.boolean(),
+    execution: z2.enum(["created", "queued", "running", "waiting_approval", "cancel_requested", "completed", "failed", "cancelled", "timed_out", "unknown"]),
+    artifact: z2.strictObject({
+      observedDigest: digest.nullable(),
+      deliveredDigest: digest.nullable(),
+      correspondence: z2.enum(["current", "stale", "missing"]),
+      paths: z2.array(text).max(256),
+      contents: z2.literal("not_included")
+    }),
+    review: z2.strictObject({
+      structure: z2.enum(["verified", "incomplete"]),
+      semantic: z2.literal("pending"),
+      acceptance: z2.literal("not_recorded"),
+      human: z2.array(z2.strictObject({ id: text, requirement: text, status: z2.literal("pending") })).max(32),
+      checks: z2.array(z2.strictObject({ id: text, status: z2.enum(["confirmed", "missing", "missing_or_stale", "host_policy_changed"]), provenance: z2.literal("contract_snapshot_and_tool_journal") })).max(32)
+    }),
+    budget: z2.strictObject({
+      availability: z2.enum(["authoritative", "legacy_not_enabled"]),
+      revision: count.nullable(),
+      confirmed: tokens.nullable(),
+      reserved: tokens.nullable(),
+      unknown: tokens.nullable(),
+      remaining: tokens.nullable(),
+      limits: tokens.nullable(),
+      estimated: z2.null(),
+      estimation: z2.literal("not_separately_recorded"),
+      usageComplete: z2.boolean().nullable(),
+      admissionsClosed: z2.boolean().nullable(),
+      monetary: z2.strictObject({ estimatedConfirmedUsd: z2.number().finite().nonnegative().nullable(), reservedUsd: z2.number().finite().nonnegative().nullable(), unknownHeldUsd: z2.number().finite().nonnegative().nullable(), remainingUsd: z2.number().finite().nonnegative().nullable(), unknown: z2.boolean(), costKind: z2.literal("estimate-not-invoice") })
+    }),
+    effects: z2.strictObject({ readOnly: count, recorded: count, unknown: count, missingEvidence: z2.boolean(), automaticReplay: z2.literal(false), providerStopped: z2.literal("unconfirmed") }),
+    nextAction: z2.strictObject({
+      kind: z2.enum(["wait", "reconcile", "review_approval", "review_delivery", "explicit_continuation"]),
+      permitted: z2.literal("read_only"),
+      authorization: z2.literal("required_for_execution"),
+      preserves: z2.literal("contract_receipts_budget_and_effects"),
+      automaticReplay: z2.literal(false)
+    }),
+    diagnostic: z2.strictObject({ code: z2.enum(["EXECUTION_FAILED", "EXECUTION_CANCELLED", "EXECUTION_TIMED_OUT", "EVIDENCE_INCOMPLETE"]), cause: z2.enum(["execution_terminal_failure", "operator_or_runtime_cancellation", "execution_deadline", "receipts_missing_or_stale"]), impact: z2.literal("acceptance_not_established"), safeAction: z2.enum(["review_configuration", "reconcile", "review_delivery"]) }).nullable(),
+    reasons: z2.array(z2.string().regex(/^[A-Z][A-Z0-9_]{0,95}$/)).max(32),
+    provenance: z2.literal("host_durable_contract_journal_budget_and_fresh_native_snapshot"),
+    textTruncated: z2.boolean()
+  })
+});
+
+// src/approvals/approval-diff.ts
+import { z as z3 } from "zod";
+var sha = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
+var file = z3.object({ path: z3.string().max(1024), expectedDigest: sha.nullable(), before: z3.string().nullable(), after: z3.string().nullable(), afterDigest: sha.nullable(), beforeMode: z3.number().int().optional(), afterMode: z3.number().int().optional(), operation: z3.enum(["create", "update", "delete", "restore"]).optional() }).strict();
+var archive = z3.object({ approvalId: z3.string().max(256), digest: z3.string().regex(/^[a-f0-9]{64}$/), proposalId: sha, files: z3.array(file).min(1).max(50) }).strict();
+var archives = z3.array(archive).max(512);
 var maxBytes = 2 * 1024 * 1024;
 
 // src/approvals/approval-preview.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/client/local-service.ts
-var harnessLocalCredentialsSchema = z4.object({ schemaVersion: z4.literal(1), socketPath: z4.string().min(1), token: z4.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var harnessLocalCredentialsSchema = z5.object({ schemaVersion: z5.literal(1), socketPath: z5.string().min(1), token: z5.string().regex(/^[a-f0-9]{64}$/) }).strict();
 var readHarnessLocalCredentials = async (filename) => {
   const { constants } = await import("node:fs");
   const file2 = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
@@ -161,26 +256,26 @@ var requestHarnessLocalService = async (credentials, endpoint, payload) => {
 };
 
 // src/client/json-contracts.ts
-import { z as z5 } from "zod";
-var observationalDocument = (shape) => z5.object(shape).passthrough();
-var jsonBase = { schemaVersion: z5.literal(CLI_JSON_SCHEMA_VERSION) };
+import { z as z6 } from "zod";
+var observationalDocument = (shape) => z6.object(shape).passthrough();
+var jsonBase = { schemaVersion: z6.literal(CLI_JSON_SCHEMA_VERSION) };
 var eventBase = {
-  schemaVersion: z5.literal(CLI_EVENT_SCHEMA_VERSION),
-  sequence: z5.number().int().nonnegative()
+  schemaVersion: z6.literal(CLI_EVENT_SCHEMA_VERSION),
+  sequence: z6.number().int().nonnegative()
 };
-var nonnegativeInteger = z5.number().int().nonnegative();
-var digestSchema = z5.string().regex(/^sha256:[a-f0-9]{64}$/);
+var nonnegativeInteger = z6.number().int().nonnegative();
+var digestSchema = z6.string().regex(/^sha256:[a-f0-9]{64}$/);
 var jsonObjectSchema = observationalDocument({});
 var scopeSchema = observationalDocument({
-  tenantId: z5.string().min(1),
-  userId: z5.string().min(1).optional(),
-  namespace: z5.string().min(1).optional()
+  tenantId: z6.string().min(1),
+  userId: z6.string().min(1).optional(),
+  namespace: z6.string().min(1).optional()
 });
 var runIdentity = {
-  runId: z5.string().min(1),
-  status: z5.string().min(1),
-  provider: z5.string().min(1),
-  model: z5.string().min(1)
+  runId: z6.string().min(1),
+  status: z6.string().min(1),
+  provider: z6.string().min(1),
+  model: z6.string().min(1)
 };
 var runSummarySchema = observationalDocument({
   ...runIdentity,
@@ -196,24 +291,24 @@ var runSummarySchema = observationalDocument({
   updatedAt: nonnegativeInteger
 });
 var sessionRunSchema = observationalDocument({
-  turnId: z5.string().min(1),
+  turnId: z6.string().min(1),
   sequence: nonnegativeInteger,
-  runId: z5.string().min(1),
-  provider: z5.string().min(1),
-  model: z5.string().min(1),
-  status: z5.string().min(1),
+  runId: z6.string().min(1),
+  provider: z6.string().min(1),
+  model: z6.string().min(1),
+  status: z6.string().min(1),
   createdAt: nonnegativeInteger,
   updatedAt: nonnegativeInteger
 });
 var sessionSchema = observationalDocument({
-  schemaVersion: z5.literal(1),
-  sessionId: z5.string().min(1),
-  workspaceKey: z5.string().min(1),
-  scopeKey: z5.string().min(1),
+  schemaVersion: z6.literal(1),
+  sessionId: z6.string().min(1),
+  workspaceKey: z6.string().min(1),
+  scopeKey: z6.string().min(1),
   revision: nonnegativeInteger,
   createdAt: nonnegativeInteger,
   updatedAt: nonnegativeInteger,
-  runs: z5.array(sessionRunSchema)
+  runs: z6.array(sessionRunSchema)
 });
 var tokenUsageSchema = observationalDocument({
   inputTokens: nonnegativeInteger.optional(),
@@ -222,19 +317,19 @@ var tokenUsageSchema = observationalDocument({
   outputTokens: nonnegativeInteger.optional(),
   reasoningTokens: nonnegativeInteger.optional(),
   totalTokens: nonnegativeInteger.optional(),
-  speed: z5.enum(["standard", "fast"]).optional()
+  speed: z6.enum(["standard", "fast"]).optional()
 });
 var budgetConfigSchema = observationalDocument({
-  unlimitedTokens: z5.boolean().optional(),
-  unlimitedSteps: z5.boolean().optional(),
-  unlimitedToolCalls: z5.boolean().optional(),
+  unlimitedTokens: z6.boolean().optional(),
+  unlimitedSteps: z6.boolean().optional(),
+  unlimitedToolCalls: z6.boolean().optional(),
   maxSteps: nonnegativeInteger,
   maxToolCalls: nonnegativeInteger,
   maxToolErrors: nonnegativeInteger,
   maxInputTokens: nonnegativeInteger,
   maxOutputTokens: nonnegativeInteger,
   maxTotalTokens: nonnegativeInteger,
-  includeChildRuns: z5.boolean()
+  includeChildRuns: z6.boolean()
 });
 var budgetConsumptionSchema = observationalDocument({
   steps: nonnegativeInteger,
@@ -255,117 +350,117 @@ var budgetRemainingSchema = observationalDocument({
 var budgetStatusSchema = observationalDocument({
   consumption: budgetConsumptionSchema,
   remaining: budgetRemainingSchema,
-  includeChildRuns: z5.boolean()
+  includeChildRuns: z6.boolean()
 });
 var costEstimateSchema = observationalDocument({
-  inputCost: z5.number().nonnegative().optional(),
-  outputCost: z5.number().nonnegative().optional(),
-  totalCost: z5.number().nonnegative().optional(),
-  currency: z5.string().min(1).optional(),
+  inputCost: z6.number().nonnegative().optional(),
+  outputCost: z6.number().nonnegative().optional(),
+  totalCost: z6.number().nonnegative().optional(),
+  currency: z6.string().min(1).optional(),
   usage: tokenUsageSchema.optional()
 });
 var mutationAuditSchema = observationalDocument({
-  id: z5.string().min(1),
-  operation: z5.enum(["create", "update", "move", "quarantine", "restore"]),
-  path: z5.string().min(1),
-  destination: z5.string().min(1).optional(),
+  id: z6.string().min(1),
+  operation: z6.enum(["create", "update", "move", "quarantine", "restore"]),
+  path: z6.string().min(1),
+  destination: z6.string().min(1).optional(),
   beforeDigest: digestSchema.optional(),
   afterDigest: digestSchema.optional(),
-  timestamp: z5.iso.datetime(),
-  quarantineId: z5.string().min(1).optional()
+  timestamp: z6.iso.datetime(),
+  quarantineId: z6.string().min(1).optional()
 });
 var approvalSummarySchema = observationalDocument({
-  id: z5.string().min(1),
-  kind: z5.string().min(1),
-  name: z5.string().min(1),
-  arguments: z5.json(),
-  childRunId: z5.string().min(1).optional(),
-  childAgentId: z5.string().min(1).optional()
+  id: z6.string().min(1),
+  kind: z6.string().min(1),
+  name: z6.string().min(1),
+  arguments: z6.json(),
+  childRunId: z6.string().min(1).optional(),
+  childAgentId: z6.string().min(1).optional()
 });
 var childRunSummarySchema = observationalDocument({
-  runId: z5.string().min(1),
-  agentId: z5.string().min(1).optional(),
-  toolName: z5.string().min(1).optional(),
-  status: z5.string().min(1),
+  runId: z6.string().min(1),
+  agentId: z6.string().min(1).optional(),
+  toolName: z6.string().min(1).optional(),
+  status: z6.string().min(1),
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
   toolErrors: nonnegativeInteger,
   usage: tokenUsageSchema.optional()
 });
 var capabilityReportSchema = observationalDocument({
-  provider: z5.string().min(1),
-  model: z5.string().min(1),
-  supportTier: z5.string().min(1).optional(),
+  provider: z6.string().min(1),
+  model: z6.string().min(1),
+  supportTier: z6.string().min(1).optional(),
   capabilities: observationalDocument({
-    streaming: z5.boolean(),
-    tools: z5.boolean(),
-    "structured-output": z5.boolean(),
-    "parallel-tools": z5.boolean(),
-    reasoning: z5.boolean(),
-    "web-search": z5.boolean()
+    streaming: z6.boolean(),
+    tools: z6.boolean(),
+    "structured-output": z6.boolean(),
+    "parallel-tools": z6.boolean(),
+    reasoning: z6.boolean(),
+    "web-search": z6.boolean()
   })
 });
-var providerConfigurationSchema = z5.object({
-  customEndpoint: z5.boolean(),
-  endpointValid: z5.boolean(),
-  endpointSecure: z5.boolean()
-}).catchall(z5.boolean());
+var providerConfigurationSchema = z6.object({
+  customEndpoint: z6.boolean(),
+  endpointValid: z6.boolean(),
+  endpointSecure: z6.boolean()
+}).catchall(z6.boolean());
 var providerAvailabilitySchema = observationalDocument({
-  id: z5.string().min(1),
-  name: z5.string().min(1),
-  defaultModel: z5.string().min(1),
-  credentialNames: z5.array(z5.string().min(1)),
-  capabilities: z5.array(z5.enum(["streaming", "tool-calling", "approval-resume"])),
-  support: z5.enum(["certified", "provisional"]),
-  configured: z5.boolean(),
-  credentials: z5.array(observationalDocument({
-    name: z5.string().min(1),
-    present: z5.boolean()
+  id: z6.string().min(1),
+  name: z6.string().min(1),
+  defaultModel: z6.string().min(1),
+  credentialNames: z6.array(z6.string().min(1)),
+  capabilities: z6.array(z6.enum(["streaming", "tool-calling", "approval-resume"])),
+  support: z6.enum(["certified", "provisional"]),
+  configured: z6.boolean(),
+  credentials: z6.array(observationalDocument({
+    name: z6.string().min(1),
+    present: z6.boolean()
   })),
   configuration: providerConfigurationSchema
 });
 var orchestrationConfigSchema = observationalDocument({
-  profiles: z5.array(z5.enum(["explorer", "implementer", "tester", "reviewer"])),
+  profiles: z6.array(z6.enum(["explorer", "implementer", "tester", "reviewer"])),
   childBudget: budgetConfigSchema,
   childTimeoutMs: nonnegativeInteger,
   maxParallelReviews: nonnegativeInteger
 });
-var executionConfigSchema = z5.discriminatedUnion("backend", [
-  observationalDocument({ backend: z5.literal("none") }),
+var executionConfigSchema = z6.discriminatedUnion("backend", [
+  observationalDocument({ backend: z6.literal("none") }),
   observationalDocument({
-    backend: z5.literal("oci"),
-    policyVersion: z5.string().min(1),
-    runtime: z5.enum(["docker", "podman"]),
-    image: z5.string().min(1),
-    allowedCommands: z5.array(z5.string().min(1)),
-    shellMode: z5.enum(["deny", "ask"]),
+    backend: z6.literal("oci"),
+    policyVersion: z6.string().min(1),
+    runtime: z6.enum(["docker", "podman"]),
+    image: z6.string().min(1),
+    allowedCommands: z6.array(z6.string().min(1)),
+    shellMode: z6.enum(["deny", "ask"]),
     maxProcessRuntimeMs: nonnegativeInteger,
     maxProcessOutputBytes: nonnegativeInteger,
     maxMemoryMb: nonnegativeInteger,
     maxPids: nonnegativeInteger,
-    maxCpus: z5.number().positive(),
+    maxCpus: z6.number().positive(),
     maxWorkspaceBytes: nonnegativeInteger,
     maxFileWriteBytes: nonnegativeInteger,
     tmpfsMb: nonnegativeInteger
   })
 ]);
 var executionBindingSchema = observationalDocument({
-  environmentId: z5.string().min(1),
-  environmentVersion: z5.string().min(1).optional(),
-  fingerprint: z5.string().min(1),
-  workspaceId: z5.string().min(1).optional()
+  environmentId: z6.string().min(1),
+  environmentVersion: z6.string().min(1).optional(),
+  fingerprint: z6.string().min(1),
+  workspaceId: z6.string().min(1).optional()
 });
 var ociImageSchema = observationalDocument({
-  runtime: z5.enum(["docker", "podman"]),
-  runtimeVersion: z5.string().min(1),
-  imageReference: z5.string().min(1),
-  imageId: z5.string().min(1),
-  imageDigest: z5.string().min(1)
+  runtime: z6.enum(["docker", "podman"]),
+  runtimeVersion: z6.string().min(1),
+  imageReference: z6.string().min(1),
+  imageId: z6.string().min(1),
+  imageDigest: z6.string().min(1)
 });
-var runExecutionSchema = z5.discriminatedUnion("backend", [
-  observationalDocument({ backend: z5.literal("none") }),
+var runExecutionSchema = z6.discriminatedUnion("backend", [
+  observationalDocument({ backend: z6.literal("none") }),
   observationalDocument({
-    backend: z5.literal("oci"),
+    backend: z6.literal("oci"),
     binding: executionBindingSchema,
     image: ociImageSchema
   })
@@ -376,45 +471,45 @@ var migrationResultSchema = observationalDocument({
   migratedToolCalls: nonnegativeInteger
 });
 var runStoreSchema = observationalDocument({
-  backend: z5.enum(["sqlite", "file"]),
-  stateDirectory: z5.string().min(1),
+  backend: z6.enum(["sqlite", "file"]),
+  stateDirectory: z6.string().min(1),
   migration: migrationResultSchema.optional()
 });
 var doctorCheckSchema = observationalDocument({
-  id: z5.string().min(1),
-  status: z5.enum(["pass", "warn", "fail"]),
-  message: z5.string(),
-  details: z5.record(z5.string(), z5.union([
-    z5.boolean(),
-    z5.number(),
-    z5.string(),
-    z5.array(z5.string())
+  id: z6.string().min(1),
+  status: z6.enum(["pass", "warn", "fail"]),
+  message: z6.string(),
+  details: z6.record(z6.string(), z6.union([
+    z6.boolean(),
+    z6.number(),
+    z6.string(),
+    z6.array(z6.string())
   ]))
 });
 var doctorConfigurationSchema = observationalDocument({
-  requireVerifiedDelivery: z5.boolean().optional(),
-  provider: z5.string().min(1),
-  model: z5.string().min(1),
-  workspace: z5.string().min(1),
-  stateDirectory: z5.string().min(1),
-  storeBackend: z5.enum(["sqlite", "file"]),
+  requireVerifiedDelivery: z6.boolean().optional(),
+  provider: z6.string().min(1),
+  model: z6.string().min(1),
+  workspace: z6.string().min(1),
+  stateDirectory: z6.string().min(1),
+  storeBackend: z6.enum(["sqlite", "file"]),
   scope: scopeSchema,
   maxSteps: nonnegativeInteger,
   timeoutMs: nonnegativeInteger,
-  unlimitedDuration: z5.boolean().optional(),
+  unlimitedDuration: z6.boolean().optional(),
   budget: budgetConfigSchema,
   costBudget: observationalDocument({
-    maxCostUsd: z5.number().nonnegative(),
-    inputCostPer1kTokens: z5.number().nonnegative(),
-    outputCostPer1kTokens: z5.number().nonnegative()
+    maxCostUsd: z6.number().nonnegative(),
+    inputCostPer1kTokens: z6.number().nonnegative(),
+    outputCostPer1kTokens: z6.number().nonnegative()
   }).optional(),
   compaction: observationalDocument({
     maxMessages: nonnegativeInteger,
     maxEstimatedInputTokens: nonnegativeInteger,
     keepRecentMessages: nonnegativeInteger
   }),
-  allowedChecks: z5.array(z5.string().min(1)),
-  requiredCapabilities: z5.array(z5.enum([
+  allowedChecks: z6.array(z6.string().min(1)),
+  requiredCapabilities: z6.array(z6.enum([
     "streaming",
     "tools",
     "structured-output",
@@ -423,24 +518,24 @@ var doctorConfigurationSchema = observationalDocument({
     "web-search"
   ])),
   orchestration: orchestrationConfigSchema,
-  context: observationalDocument({ enabled: z5.boolean(), configPath: z5.string().min(1) }),
+  context: observationalDocument({ enabled: z6.boolean(), configPath: z6.string().min(1) }),
   execution: executionConfigSchema,
-  mcpConfigPath: z5.string().min(1).optional()
+  mcpConfigPath: z6.string().min(1).optional()
 });
 var cliRunResultDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("run-result"),
+  kind: z6.literal("run-result"),
   ...runIdentity,
-  output: z5.string(),
+  output: z6.string(),
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
-  mutations: z5.array(mutationAuditSchema),
-  pendingApprovals: z5.array(approvalSummarySchema),
-  children: z5.array(childRunSummarySchema),
+  mutations: z6.array(mutationAuditSchema),
+  pendingApprovals: z6.array(approvalSummarySchema),
+  children: z6.array(childRunSummarySchema),
   usage: tokenUsageSchema.optional(),
   budget: budgetStatusSchema,
   costBudget: observationalDocument({
-    limitUsd: z5.number().nonnegative(),
+    limitUsd: z6.number().nonnegative(),
     estimate: costEstimateSchema
   }).optional(),
   scope: scopeSchema,
@@ -448,65 +543,65 @@ var cliRunResultDocumentSchema = observationalDocument({
   orchestration: observationalDocument({
     profiles: orchestrationConfigSchema.shape.profiles,
     childBudget: budgetConfigSchema,
-    mcpServers: z5.array(z5.string().min(1))
+    mcpServers: z6.array(z6.string().min(1))
   }),
   execution: runExecutionSchema,
   store: runStoreSchema,
-  stateDirectory: z5.string()
+  stateDirectory: z6.string()
 });
 var cliProviderDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("providers"),
-  providers: z5.array(providerAvailabilitySchema)
+  kind: z6.literal("providers"),
+  providers: z6.array(providerAvailabilitySchema)
 });
 var cliInitDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("init"),
+  kind: z6.literal("init"),
   profile: observationalDocument({
-    name: z5.string().min(1),
-    path: z5.string().min(1),
+    name: z6.string().min(1),
+    path: z6.string().min(1),
     schemaVersion: nonnegativeInteger,
-    provider: z5.enum(PROVIDERS),
-    model: z5.string().min(1),
+    provider: z6.enum(PROVIDERS),
+    model: z6.string().min(1),
     reasoningEffort: reasoningEffortSchema.optional()
   }),
   credential: observationalDocument({
-    configured: z5.boolean(),
-    names: z5.array(z5.string().min(1))
+    configured: z6.boolean(),
+    names: z6.array(z6.string().min(1))
   }),
   next: observationalDocument({
-    doctor: z5.string().min(1),
-    run: z5.string().min(1)
+    doctor: z6.string().min(1),
+    run: z6.string().min(1)
   })
 });
 var cliDoctorDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("doctor"),
-  ok: z5.boolean(),
-  harnessVersion: z5.string().min(1),
+  kind: z6.literal("doctor"),
+  ok: z6.boolean(),
+  harnessVersion: z6.string().min(1),
   configSchemaVersion: nonnegativeInteger,
   configuration: doctorConfigurationSchema,
-  checks: z5.array(doctorCheckSchema),
-  providers: z5.array(providerAvailabilitySchema)
+  checks: z6.array(doctorCheckSchema),
+  providers: z6.array(providerAvailabilitySchema)
 });
 var cliReviewGroupDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("review-group"),
-  groupId: z5.string().min(1),
-  status: z5.enum(["completed", "failed"]),
-  profiles: z5.array(z5.string().min(1)).min(1),
-  outputs: z5.array(observationalDocument({
-    status: z5.enum(["fulfilled", "rejected"]),
-    name: z5.string().min(1).optional(),
-    agentId: z5.string().min(1).optional(),
-    runId: z5.string().min(1).optional(),
-    runStatus: z5.string().min(1).optional(),
-    output: z5.string().optional(),
+  kind: z6.literal("review-group"),
+  groupId: z6.string().min(1),
+  status: z6.enum(["completed", "failed"]),
+  profiles: z6.array(z6.string().min(1)).min(1),
+  outputs: z6.array(observationalDocument({
+    status: z6.enum(["fulfilled", "rejected"]),
+    name: z6.string().min(1).optional(),
+    agentId: z6.string().min(1).optional(),
+    runId: z6.string().min(1).optional(),
+    runStatus: z6.string().min(1).optional(),
+    output: z6.string().optional(),
     steps: nonnegativeInteger.optional(),
     usage: tokenUsageSchema.optional(),
     error: observationalDocument({
-      code: z5.enum(HARNESS_ERROR_CODES),
-      category: z5.enum([
+      code: z6.enum(HARNESS_ERROR_CODES),
+      category: z6.enum([
         "configuration",
         "usage",
         "workspace",
@@ -515,16 +610,16 @@ var cliReviewGroupDocumentSchema = observationalDocument({
         "approval",
         "execution"
       ]),
-      retryable: z5.boolean()
+      retryable: z6.boolean()
     }).optional()
   }))
 });
 var cliRunListDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("run-list"),
+  kind: z6.literal("run-list"),
   scope: scopeSchema,
-  backend: z5.string().min(1),
-  runs: z5.array(runSummarySchema)
+  backend: z6.string().min(1),
+  runs: z6.array(runSummarySchema)
 });
 var runInspectionShape = {
   run: runSummarySchema,
@@ -533,25 +628,25 @@ var runInspectionShape = {
   trace: jsonObjectSchema,
   hierarchy: jsonObjectSchema,
   ledger: jsonObjectSchema,
-  toolJournal: z5.array(jsonObjectSchema)
+  toolJournal: z6.array(jsonObjectSchema)
 };
 var cliRunInspectionDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("run-inspection"),
+  kind: z6.literal("run-inspection"),
   ...runInspectionShape
 });
 var cliRunExportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("run-export"),
+  kind: z6.literal("run-export"),
   ...runInspectionShape
 });
 var cliRunCancellationDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("run-cancellation"),
-  cascade: z5.boolean(),
+  kind: z6.literal("run-cancellation"),
+  cascade: z6.boolean(),
   run: runSummarySchema.optional(),
   parent: runSummarySchema.optional(),
-  children: z5.array(runSummarySchema).optional()
+  children: z6.array(runSummarySchema).optional()
 }).superRefine((document, context) => {
   if (!document.cascade && !document.run || document.cascade && (!document.parent || !document.children)) {
     context.addIssue({ code: "custom", message: "Cancellation payload does not match cascade mode." });
@@ -559,27 +654,27 @@ var cliRunCancellationDocumentSchema = observationalDocument({
 });
 var cliRunCleanupDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("run-cleanup"),
+  kind: z6.literal("run-cleanup"),
   before: nonnegativeInteger,
-  statuses: z5.array(z5.string().min(1)),
+  statuses: z6.array(z6.string().min(1)),
   deleted: nonnegativeInteger
 });
 var cliSessionListDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("session-list"),
-  sessions: z5.array(sessionSchema)
+  kind: z6.literal("session-list"),
+  sessions: z6.array(sessionSchema)
 });
 var cliSessionDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("session"),
+  kind: z6.literal("session"),
   session: sessionSchema
 });
 var cliChangeEnvelopeVerificationDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("change-envelope-verification"),
-  valid: z5.boolean(),
-  verificationScope: z5.literal("integrity-expiration-and-preconditions-only"),
-  issues: z5.array(jsonObjectSchema),
+  kind: z6.literal("change-envelope-verification"),
+  valid: z6.boolean(),
+  verificationScope: z6.literal("integrity-expiration-and-preconditions-only"),
+  issues: z6.array(jsonObjectSchema),
   integrity: jsonObjectSchema,
   expiration: jsonObjectSchema,
   checks: jsonObjectSchema,
@@ -588,39 +683,39 @@ var cliChangeEnvelopeVerificationDocumentSchema = observationalDocument({
 });
 var cliStateStatusDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("state-status"),
-  compatible: z5.boolean(),
+  kind: z6.literal("state-status"),
+  compatible: z6.boolean(),
   schemas: jsonObjectSchema,
-  counts: z5.record(z5.string(), nonnegativeInteger)
+  counts: z6.record(z6.string(), nonnegativeInteger)
 });
 var cliStateExportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("state-export"),
-  path: z5.string().min(1),
+  kind: z6.literal("state-export"),
+  path: z6.string().min(1),
   checksum: digestSchema,
-  counts: z5.record(z5.string(), nonnegativeInteger)
+  counts: z6.record(z6.string(), nonnegativeInteger)
 });
 var cliStateImportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("state-import"),
-  dryRun: z5.boolean(),
+  kind: z6.literal("state-import"),
+  dryRun: z6.boolean(),
   checksum: digestSchema,
-  inserted: z5.record(z5.string(), nonnegativeInteger),
+  inserted: z6.record(z6.string(), nonnegativeInteger),
   identical: nonnegativeInteger
 });
-var providerStreamDiagnosticSchema = z5.strictObject({
-  provider: z5.literal("qwen"),
-  transport: z5.enum(["chat", "responses"]),
-  diagnosticCode: z5.literal("QWEN_SSE_EVENT_INVALID"),
-  reason: z5.enum(["invalid_json", "invalid_event"]),
-  retryable: z5.literal(false)
+var providerStreamDiagnosticSchema = z6.strictObject({
+  provider: z6.literal("qwen"),
+  transport: z6.enum(["chat", "responses"]),
+  diagnosticCode: z6.literal("QWEN_SSE_EVENT_INVALID"),
+  reason: z6.enum(["invalid_json", "invalid_event"]),
+  retryable: z6.literal(false)
 });
 var cliErrorDocumentSchema = observationalDocument({
-  schemaVersion: z5.literal(HARNESS_ERROR_SCHEMA_VERSION),
-  kind: z5.literal("error"),
+  schemaVersion: z6.literal(HARNESS_ERROR_SCHEMA_VERSION),
+  kind: z6.literal("error"),
   error: observationalDocument({
-    code: z5.enum(HARNESS_ERROR_CODES),
-    category: z5.enum([
+    code: z6.enum(HARNESS_ERROR_CODES),
+    category: z6.enum([
       "configuration",
       "usage",
       "workspace",
@@ -629,22 +724,22 @@ var cliErrorDocumentSchema = observationalDocument({
       "approval",
       "execution"
     ]),
-    retryable: z5.boolean(),
+    retryable: z6.boolean(),
     providerDiagnostic: providerStreamDiagnosticSchema.optional()
   })
 });
 var cliPolicyInspectionSchema = observationalDocument({
   ...jsonBase,
-  kind: z5.literal("policy-inspection"),
+  kind: z6.literal("policy-inspection"),
   digest: digestSchema.nullable(),
-  source: z5.enum(["operator-file", "application", "baseline"]),
-  explicitReviewRequired: z5.boolean(),
-  tools: z5.array(observationalDocument({ name: z5.string(), requiresApproval: z5.boolean() })),
-  restrictions: z5.array(observationalDocument({ ruleId: z5.string(), tools: z5.array(z5.string()), decision: z5.enum(["allow", "ask_user", "deny"]), reason: z5.string(), pathCount: nonnegativeInteger })),
-  execution: observationalDocument({ configuredBackend: z5.enum(["none", "oci"]), activeBackend: z5.enum(["none", "oci"]), evidence: z5.literal("configuration-only") }),
-  limits: observationalDocument({ maxSteps: nonnegativeInteger, timeoutMs: nonnegativeInteger, unlimitedDuration: z5.boolean().optional(), budget: jsonObjectSchema })
+  source: z6.enum(["operator-file", "application", "baseline"]),
+  explicitReviewRequired: z6.boolean(),
+  tools: z6.array(observationalDocument({ name: z6.string(), requiresApproval: z6.boolean() })),
+  restrictions: z6.array(observationalDocument({ ruleId: z6.string(), tools: z6.array(z6.string()), decision: z6.enum(["allow", "ask_user", "deny"]), reason: z6.string(), pathCount: nonnegativeInteger })),
+  execution: observationalDocument({ configuredBackend: z6.enum(["none", "oci"]), activeBackend: z6.enum(["none", "oci"]), evidence: z6.literal("configuration-only") }),
+  limits: observationalDocument({ maxSteps: nonnegativeInteger, timeoutMs: nonnegativeInteger, unlimitedDuration: z6.boolean().optional(), budget: jsonObjectSchema })
 });
-var cliJsonDocumentSchema = z5.union([
+var cliJsonDocumentSchema = z6.union([
   cliPolicyInspectionSchema,
   cliRunResultDocumentSchema,
   cliInitDocumentSchema,
@@ -667,108 +762,108 @@ var cliJsonDocumentSchema = z5.union([
 ]);
 var runEvent = (type, shape) => observationalDocument({
   ...eventBase,
-  kind: z5.literal("run-event"),
-  type: z5.literal(type),
+  kind: z6.literal("run-event"),
+  type: z6.literal(type),
   ...shape
 });
-var cliRunEventDocumentSchema = z5.discriminatedUnion("type", [
+var cliRunEventDocumentSchema = z6.discriminatedUnion("type", [
   runEvent("policy-decision", {
-    phase: z5.enum(["approval-request", "tool-entry"]),
-    toolName: z5.string(),
-    decision: z5.enum(["allow", "ask_user", "deny"]),
-    ruleIds: z5.array(z5.string()),
-    reason: z5.string(),
-    reasonTruncated: z5.boolean(),
+    phase: z6.enum(["approval-request", "tool-entry"]),
+    toolName: z6.string(),
+    decision: z6.enum(["allow", "ask_user", "deny"]),
+    ruleIds: z6.array(z6.string()),
+    reason: z6.string(),
+    reasonTruncated: z6.boolean(),
     policyDigest: digestSchema.nullable(),
-    source: z5.enum(["operator-file", "application", "baseline"]),
-    approvalRequired: z5.boolean(),
-    explicitReviewRequired: z5.boolean(),
-    executionBackend: z5.enum(["none", "oci"]),
-    evidence: z5.literal("policy-evaluation")
+    source: z6.enum(["operator-file", "application", "baseline"]),
+    approvalRequired: z6.boolean(),
+    explicitReviewRequired: z6.boolean(),
+    executionBackend: z6.enum(["none", "oci"]),
+    evidence: z6.literal("policy-evaluation")
   }),
-  runEvent("text-delta", { textDelta: z5.string() }),
+  runEvent("text-delta", { textDelta: z6.string() }),
   runEvent("tool-call", {
-    toolCallId: z5.string().min(1),
-    toolName: z5.string().min(1)
+    toolCallId: z6.string().min(1),
+    toolName: z6.string().min(1)
   }),
   runEvent("tool-result", {
-    toolCallId: z5.string().min(1),
-    toolName: z5.string().min(1),
-    isError: z5.boolean()
+    toolCallId: z6.string().min(1),
+    toolName: z6.string().min(1),
+    isError: z6.boolean()
   }),
   runEvent("tool-approval-request", {
-    approvalRequestId: z5.string().min(1),
-    approvalKind: z5.string().min(1),
-    toolName: z5.string().min(1)
+    approvalRequestId: z6.string().min(1),
+    approvalKind: z6.string().min(1),
+    toolName: z6.string().min(1)
   }),
   runEvent("agent-approval-request", {
-    approvalRequestId: z5.string().min(1),
-    approvalKind: z5.string().min(1),
-    toolName: z5.string().min(1)
+    approvalRequestId: z6.string().min(1),
+    approvalKind: z6.string().min(1),
+    toolName: z6.string().min(1)
   }),
   runEvent("agent-approval-resolved", {
-    approvalRequestId: z5.string().min(1),
-    approved: z5.boolean()
+    approvalRequestId: z6.string().min(1),
+    approved: z6.boolean()
   }),
-  runEvent("provider-data", { provider: z5.string().min(1) }),
+  runEvent("provider-data", { provider: z6.string().min(1) }),
   runEvent("image-generation", {
-    provider: z5.string().min(1),
-    partial: z5.boolean(),
-    id: z5.string().min(1).optional(),
+    provider: z6.string().min(1),
+    partial: z6.boolean(),
+    id: z6.string().min(1).optional(),
     index: nonnegativeInteger.optional()
   }),
   runEvent("finish", {
-    finishReason: z5.string().min(1).optional(),
+    finishReason: z6.string().min(1).optional(),
     usage: jsonObjectSchema.optional()
   }),
-  runEvent("error", { error: z5.literal("Provider stream failed."), providerDiagnostic: providerStreamDiagnosticSchema.optional() }),
+  runEvent("error", { error: z6.literal("Provider stream failed."), providerDiagnostic: providerStreamDiagnosticSchema.optional() }),
   runEvent("agent-run-start", {
     currentStep: nonnegativeInteger,
-    maxSteps: z5.union([nonnegativeInteger, z5.literal("unlimited")])
+    maxSteps: z6.union([nonnegativeInteger, z6.literal("unlimited")])
   }),
   runEvent("agent-step-start", { stepIndex: nonnegativeInteger }),
   runEvent("agent-step-finish", {
     stepIndex: nonnegativeInteger,
-    status: z5.string().min(1),
+    status: z6.string().min(1),
     toolCalls: nonnegativeInteger
   }),
   runEvent("agent-compaction", {
-    compactionId: z5.string().min(1),
-    reasons: z5.array(z5.string().min(1)),
+    compactionId: z6.string().min(1),
+    reasons: z6.array(z6.string().min(1)),
     messageCountBefore: nonnegativeInteger,
     messageCountAfter: nonnegativeInteger
   }),
   runEvent("agent-run-finish", {
-    runId: z5.string().min(1),
-    status: z5.string().min(1),
-    provider: z5.string().min(1),
-    model: z5.string().min(1)
+    runId: z6.string().min(1),
+    status: z6.string().min(1),
+    provider: z6.string().min(1),
+    model: z6.string().min(1)
   })
 ]);
 var cliStreamResultDocumentSchema = observationalDocument({
   ...eventBase,
-  kind: z5.literal("run-stream-result"),
+  kind: z6.literal("run-stream-result"),
   ...runIdentity,
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
-  pendingApprovals: z5.array(observationalDocument({
-    id: z5.string().min(1),
-    kind: z5.string().min(1),
-    name: z5.string().min(1),
-    childRunId: z5.string().min(1).optional(),
-    childAgentId: z5.string().min(1).optional()
+  pendingApprovals: z6.array(observationalDocument({
+    id: z6.string().min(1),
+    kind: z6.string().min(1),
+    name: z6.string().min(1),
+    childRunId: z6.string().min(1).optional(),
+    childAgentId: z6.string().min(1).optional()
   })),
-  children: z5.array(observationalDocument({
-    runId: z5.string().min(1),
-    status: z5.string().min(1)
+  children: z6.array(observationalDocument({
+    runId: z6.string().min(1),
+    status: z6.string().min(1)
   }))
 });
 var cliStreamErrorDocumentSchema = observationalDocument({
   ...eventBase,
-  kind: z5.literal("run-stream-error"),
+  kind: z6.literal("run-stream-error"),
   error: cliErrorDocumentSchema.shape.error
 });
-var cliJsonLineDocumentSchema = z5.union([
+var cliJsonLineDocumentSchema = z6.union([
   cliRunEventDocumentSchema,
   cliStreamResultDocumentSchema,
   cliStreamErrorDocumentSchema
@@ -880,8 +975,8 @@ var runServiceCli = async (options, annotate) => {
     let cursor = await cursorAtEnd();
     let finished = false, streamed = false;
     consoleInput?.startBackground();
-    const activity = new ToolActivity((text) => {
-      process.stderr.write(text);
+    const activity = new ToolActivity((text2) => {
+      process.stderr.write(text2);
     }, Boolean(consoleInput && process.stdout.isTTY), () => process.stdout.columns || 80, () => consoleInput?.backgroundStatus ?? "");
     const observe = (a) => {
       if (options.json || options.jsonl)
@@ -1060,60 +1155,60 @@ Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
         });
         const literal = input.lastSubmissionWasPaste || raw.includes(`
 `);
-        let text = literal ? raw : raw.trim();
-        if (!text)
+        let text2 = literal ? raw : raw.trim();
+        if (!text2)
           continue;
-        if (!literal && ["/exit", "/quit"].includes(text))
+        if (!literal && ["/exit", "/quit"].includes(text2))
           break;
         try {
-          if (!literal && text.startsWith("/")) {
-            if (text === "/menu") {
+          if (!literal && text2.startsWith("/")) {
+            if (text2 === "/menu") {
               const selected = await navigateConsole(input, { entry: "menu", current: { provider: "service", model: "host" }, providers: [], service: true, sessions: async () => (await list()).map((s) => ({ value: s.sessionId, label: s.title ?? "Untitled conversation", detail: s.sessionId })) });
               if (!selected || !("command" in selected))
                 continue;
-              text = selected.command;
+              text2 = selected.command;
             }
-            if (text === "/help" || text === "/help all")
-              process.stdout.write(formatConsoleHelp("service", text === "/help all"));
-            else if (text === "/activity" || text === "/activity clear") {
-              if (text.endsWith(" clear"))
+            if (text2 === "/help" || text2 === "/help all")
+              process.stdout.write(formatConsoleHelp("service", text2 === "/help all"));
+            else if (text2 === "/activity" || text2 === "/activity clear") {
+              if (text2.endsWith(" clear"))
                 history.clear();
               process.stdout.write(history.render());
-            } else if (text === "/queue clear") {
+            } else if (text2 === "/queue clear") {
               input.clearQueue();
               process.stdout.write(`Queued tasks cleared.
 `);
-            } else if (text === "/queue")
+            } else if (text2 === "/queue")
               process.stdout.write(input.queueSummary());
-            else if (text === "/sessions" || text.startsWith("/sessions "))
-              print(await list(text.slice(9).trim() || undefined));
-            else if (text === "/new") {
+            else if (text2 === "/sessions" || text2.startsWith("/sessions "))
+              print(await list(text2.slice(9).trim() || undefined));
+            else if (text2 === "/new") {
               session2 = await create();
               input.clearHistory();
               history.clear();
               seenMutations.clear();
               process.stdout.write(`Session ${session2.sessionId}.
 `);
-            } else if (text === "/resume" || text.startsWith("/resume ")) {
-              let id2 = text.slice(7).trim();
-              if (!id2) {
+            } else if (text2 === "/resume" || text2.startsWith("/resume ")) {
+              let id3 = text2.slice(7).trim();
+              if (!id3) {
                 const selected = await input.select("Zhivex / Conversations", (await list()).map((s) => ({ value: s.sessionId, label: s.title ?? "Untitled conversation", detail: s.sessionId })));
                 if (!selected)
                   continue;
-                id2 = selected;
+                id3 = selected;
               }
-              session2 = await getSession(id2);
+              session2 = await getSession(id3);
               input.clearHistory();
               history.clear();
               seenMutations.clear();
               print(await currentRun());
-            } else if (text.startsWith("/rename ")) {
-              const r = await call({ method: "session.rename", sessionId: session2.sessionId, expectedRevision: session2.revision, idempotencyKey: key("rename"), title: text.slice(8) });
+            } else if (text2.startsWith("/rename ")) {
+              const r = await call({ method: "session.rename", sessionId: session2.sessionId, expectedRevision: session2.revision, idempotencyKey: key("rename"), title: text2.slice(8) });
               if (r.kind === "session")
                 session2 = r.session;
-            } else if (["/status", "/pending"].includes(text))
+            } else if (["/status", "/pending"].includes(text2))
               print(await currentRun() ?? { message: "No run yet." });
-            else if (text === "/paste") {
+            else if (text2 === "/paste") {
               const draft = await input.multiline();
               process.stdout.write(`Draft preview:
 ${sanitizeTerminalText(draft)}
@@ -1122,20 +1217,20 @@ ${sanitizeTerminalText(draft)}
                 input.rememberPrompt(draft, true);
                 await start(draft);
               }
-            } else if (text === "/cancel")
+            } else if (text2 === "/cancel")
               await cancel();
-            else if (["/approve", "/deny"].includes(text)) {
+            else if (["/approve", "/deny"].includes(text2)) {
               const run2 = await currentRun();
               if (run2) {
-                const r = await decision(run2, text === "/approve");
+                const r = await decision(run2, text2 === "/approve");
                 finish(r.run, r.streamed);
               }
             } else
               process.stdout.write(`Unsupported service command. Use /help.
 `);
           } else {
-            input.rememberPrompt(text, literal);
-            await start(text);
+            input.rememberPrompt(text2, literal);
+            await start(text2);
           }
         } catch {
           if (input.isClosed)