@zhivex-ai/harness 1.2.0-rc.9 → 1.2.0

package/dist/{cli-2dxcfrz5.js → cli-3jmy4h5h.js}

@@ -5,8 +5,9 @@ import {
   resolveHelpTopic,
   shortCliHelp,
   validateCliCommandOptions
-} from "./cli-entry-0mhbpe8j.js";
+} from "./cli-entry-b1mfvmxe.js";
 import {
+  ActivityHistory,
   CLI_JSON_SCHEMA_VERSION,
   CliOciRuntimeAdapter,
   ConsoleInput,
@@ -20,6 +21,7 @@ import {
   MAX_HARNESS_CONTEXT_TOTAL_BYTES,
   SqliteDatabase,
   TASK_SOURCE_KEY,
+  ToolActivity,
   USAGE_LEDGER_KEY,
   UnsafeFileTypeError,
   Workspace,
@@ -27,16 +29,18 @@ import {
   cancelHarnessRun,
   canonicalizeChangeEnvelope,
   changeEnvelopePreconditionsSchema,
+  chooseReasoning,
   cleanupHarnessExecutionArtifacts,
   cleanupHarnessRuns,
   compactHarnessMessages,
+  compactToolResult,
   createChangeEnvelope,
   createHarness,
   digestChangeEnvelopeArtifact,
   estimateMessages,
   fileDigestSchema,
+  formatAppliedFiles,
   formatApproval,
-  formatComposer,
   formatConsoleHelp,
   formatConsoleWelcome,
   formatTerminalEvent,
@@ -53,6 +57,7 @@ import {
   navigateConsole,
   openCliSessionStore,
   openHarnessPersistence,
+  readRegularFileChunksNoFollow,
   readRegularFileNoFollow,
   resolvePackageManager,
   resolveTerminalApprovals,
@@ -63,6 +68,7 @@ import {
   sanitizeTerminalText,
   serializeStreamEvent,
   serializeStreamResult,
+  sqliteAdapter,
   taskSources,
   terminalContinuationMessages,
   terminalRunFailure,
@@ -71,7 +77,7 @@ import {
   validateStateDirectory,
   verifyChangeEnvelope,
   workspaceFilePathSchema
-} from "./cli-entry-gddtj1db.js";
+} from "./cli-entry-c2f58zj2.js";
 import {
   BUN_ENGINE_RANGE,
   HARNESS_VERSION,
@@ -89,12 +95,14 @@ import {
   PROVIDERS,
   createProviderModel,
   harnessErrorDocument,
+  modelReasoningEfforts,
   normalizeHarnessError,
   parseProvider,
   providerAvailability,
   providerDescriptor,
+  reasoningEffortSchema,
   resolveHarnessConfig
-} from "./cli-entry-t3bay5k5.js";
+} from "./cli-entry-427869g9.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -117,6 +125,7 @@ var profileNamePattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 var cliProfileSchema = z.strictObject({
   schemaVersion: z.literal(CLI_PROFILE_SCHEMA_VERSION),
   provider: z.enum(PROVIDERS),
+  reasoningEffort: reasoningEffortSchema.optional(),
   model: z.string().min(1).max(512).refine((value) => !/[\u0000-\u001f\u007f]/.test(value), "model must contain printable characters")
 });
 var absoluteDirectory = (value, source, pathApi = path) => {
@@ -224,7 +233,8 @@ var createCliProfile = async (name, input, context = {}) => {
   const parsed = cliProfileSchema.safeParse({
     schemaVersion: CLI_PROFILE_SCHEMA_VERSION,
     provider: input.provider,
-    model: input.model
+    model: input.model,
+    ...input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}
   });
   if (!parsed.success) {
     throw new HarnessConfigError(`CLI profile is invalid: ${parsed.error.issues[0]?.message ?? "schema mismatch"}`);
@@ -287,6 +297,7 @@ var applyCliProfile = async (options, context = {}) => {
   return {
     provider: profile.provider,
     model: profile.model,
+    ...profile.reasoningEffort && (!options.provider || options.provider === profile.provider) && (!options.model || options.model === profile.model) ? { reasoningEffort: profile.reasoningEffort } : {},
     ...options
   };
 };
@@ -545,6 +556,10 @@ var parseCliArgs = (argv) => {
         index += 1;
         break;
       }
+      case "--reasoning":
+        options.reasoningEffort = reasoningEffortSchema.parse(optionValue(argv, index, argument));
+        index += 1;
+        break;
       case "--require-verified-delivery":
         options.requireVerifiedDelivery = true;
         break;
@@ -1018,138 +1033,6 @@ var parseCliArgs = (argv) => {
   return options;
 };
 
-// src/cli/terminal/tool-activity.ts
-var labels = {
-  read_file: "Reading a file",
-  read_files: "Reading files",
-  read_dependency: "Inspecting a dependency",
-  search_files: "Searching files",
-  search_many: "Searching the project",
-  list_files: "Listing files",
-  run_check: "Running checks",
-  run_environment_command: "Running a command",
-  apply_patch: "Applying edits",
-  apply_reviewed_edits: "Applying reviewed edits",
-  apply_reviewed_replacement: "Applying a reviewed replacement",
-  git_diff: "Reviewing changes"
-};
-var summaries = {
-  read_file: "reads",
-  read_files: "reads",
-  read_dependency: "dependency inspections",
-  search_files: "searches",
-  search_many: "searches",
-  list_files: "listings",
-  git_diff: "diffs"
-};
-
-class ToolActivity {
-  write;
-  tty;
-  columns;
-  active = 0;
-  visible = false;
-  label = "Working";
-  completed = new Map;
-  started = Date.now();
-  timer;
-  constructor(write, tty, columns = () => 80) {
-    this.write = write;
-    this.tty = tty;
-    this.columns = columns;
-  }
-  phase(label, _step) {
-    this.clear();
-    this.label = label;
-    this.begin();
-  }
-  start(name) {
-    this.active++;
-    this.label = labels[name ?? ""] ?? "Running a tool";
-    this.begin();
-  }
-  finish(name, success = true) {
-    this.active = Math.max(0, this.active - 1);
-    if (success && !["run_check", "run_environment_command"].includes(name) && !name.startsWith("verify_and_apply_") && !editLabels[name]) {
-      const label = summaries[name] ?? "other operations";
-      this.completed.set(label, (this.completed.get(label) ?? 0) + 1);
-    }
-    this.label = this.active ? this.label : "Waiting for model response";
-    this.begin();
-  }
-  begin() {
-    this.started = Date.now();
-    this.render();
-    if (this.tty && !this.timer) {
-      this.timer = setInterval(() => this.render(), 250);
-      this.timer.unref();
-    }
-  }
-  render() {
-    if (!this.tty)
-      return;
-    const elapsed = Math.floor((Date.now() - this.started) / 1000);
-    const done = [...this.completed.values()].reduce((sum, count) => sum + count, 0);
-    const text = `… ${this.label}${elapsed ? ` · ${elapsed}s` : ""}${done ? ` · ${done} tools done` : ""}`;
-    this.write(`\r\x1B[2K${Array.from(text).slice(0, Math.max(1, this.columns() - 1)).join("")}`);
-    this.visible = true;
-  }
-  pause() {
-    this.clear();
-  }
-  clear() {
-    clearInterval(this.timer);
-    this.timer = undefined;
-    if (this.visible)
-      this.write("\r\x1B[2K");
-    this.visible = false;
-  }
-  flush() {
-    this.clear();
-    if (this.completed.size) {
-      const details = [...this.completed].map(([label, count]) => `${label}: ${count}`).join(" · ");
-      this.write(`✓ Activity · ${details}
-`);
-    }
-    this.completed.clear();
-  }
-}
-var editLabels = {
-  apply_patch: "Edits applied",
-  apply_reviewed_edits: "Reviewed edits applied",
-  apply_reviewed_replacement: "Reviewed replacement applied",
-  apply_environment_patch: "Environment changes imported"
-};
-var compactToolResult = (result) => {
-  if (!result.isError)
-    return editLabels[result.toolName] ? `✓ ${editLabels[result.toolName]}` : undefined;
-  const error = result.error && typeof result.error === "object" ? result.error : {};
-  const message = typeof error.message === "string" ? error.message : "";
-  let reason = "operation failed; inspect diagnostics for details";
-  if (error.code === "TOOL_INPUT_VALIDATION_ERROR")
-    reason = "invalid arguments; the assistant can correct and retry";
-  else if (error.code === "ENOENT" || /^ENOENT: /.test(message))
-    reason = "file not found; list files to locate the correct path";
-  else if (message.startsWith("Dependency package or path was not found in ") || message.startsWith("Dependency path was not found in "))
-    reason = "dependency path not found; list the package files before retrying";
-  else if (message.startsWith("Dependency ") && message.includes(" is not installed in this workspace's node_modules."))
-    reason = "dependency not installed; check the project installation";
-  else if (message.startsWith("Dependency paths must be package-relative;"))
-    reason = "dependency path is outside the permitted boundary; use a package-relative path";
-  else if (/^The path is protected by the harness policy: node_modules(?:\/|$)/.test(message))
-    reason = "dependency access requires the dependency tools";
-  else if (/^The path is protected by the harness policy: /.test(message))
-    reason = "path protected by workspace policy";
-  else if (message === "Dependency access only permits package.json and TypeScript declaration files.")
-    reason = "dependency file type is not permitted";
-  else if (message === "Dependency directory links are not allowed.")
-    reason = "dependency link is outside the permitted boundary";
-  else if (message.startsWith("Dependency directory changed during inspection."))
-    reason = "dependency changed during inspection; retry the read";
-  const operation = labels[result.toolName] ?? "Tool operation";
-  return `✗ ${operation} · ${reason}`;
-};
-
 // src/cli/terminal/terminal-table.ts
 var segments = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 var graphemes = (value) => [...segments.segment(value)].map((item) => item.segment);
@@ -1430,6 +1313,7 @@ var harnessConfigInput = (config) => ({
   schemaVersion: config.schemaVersion,
   provider: config.provider,
   model: config.model,
+  ...config.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {},
   workspace: config.workspace,
   stateDirectory: config.stateDirectory,
   storeBackend: config.storeBackend,
@@ -1650,6 +1534,8 @@ var toolActivities = new WeakMap;
 var lastTerminalFailures = new WeakMap;
 var flushToolActivity = (tracker) => toolActivities.get(tracker)?.flush();
 var streamSink = (output, tracker, compact = false) => async (event) => {
+  if (!output.json && !output.jsonl)
+    tracker.activityHistory?.observe(event);
   if (output.jsonl) {
     tracker.sequence = (tracker.sequence ?? 0) + 1;
     process.stdout.write(`${serializeStreamEvent(event, tracker.sequence)}
@@ -1663,7 +1549,7 @@ var streamSink = (output, tracker, compact = false) => async (event) => {
     if (!activity) {
       activity = new ToolActivity((text) => {
         process.stderr.write(text);
-      }, Boolean(process.stderr.isTTY && process.stdout.isTTY), () => process.stderr.columns || 80);
+      }, Boolean(process.stderr.isTTY && process.stdout.isTTY), () => process.stderr.columns || 80, tracker.inputStatus);
       toolActivities.set(tracker, activity);
     }
     if (event.type === "agent-compaction") {
@@ -1734,7 +1620,9 @@ var streamSink = (output, tracker, compact = false) => async (event) => {
   }
   if (!output.json && event.type === "text-delta") {
     if (compact && !conversationStarted.has(tracker)) {
-      process.stdout.write(`
+      process.stdout.write(terminalSupportsColor(Boolean(process.stdout.isTTY)) ? `
+\x1B[1mZhivex\x1B[0m
+` : `
 Zhivex
 `);
       conversationStarted.add(tracker);
@@ -1810,7 +1698,10 @@ var initializeCli = async (options, context = {}) => {
   } catch (error) {
     throw new CliUsageError(error instanceof Error ? error.message : String(error));
   }
+  let reasoningEffort = options.reasoningEffort ?? existing?.reasoningEffort;
   let model = options.model ?? (existing ? existing.provider === provider ? existing.model : providerDescriptor(provider).defaultModel : process.env.ZHIVEX_HARNESS_MODEL ?? providerDescriptor(provider).defaultModel);
+  if (existing && (existing.provider !== provider || existing.model !== model) && options.reasoningEffort === undefined)
+    reasoningEffort = undefined;
   if (!options.json && process.stdin.isTTY && process.stdout.isTTY) {
     const input = new ConsoleInput(process.stdin, process.stdout);
     try {
@@ -1818,7 +1709,7 @@ var initializeCli = async (options, context = {}) => {
         const providers = [...providerAvailability()].sort((a, b) => Number(b.configured) - Number(a.configured) || Number(b.id === provider) - Number(a.id === provider));
         const selected = await navigateConsole(input, {
           entry: options.provider ? "model" : "provider",
-          current: { provider, model },
+          current: { provider, model, ...reasoningEffort ? { reasoningEffort } : {} },
           providers,
           sessions: async () => []
         });
@@ -1829,12 +1720,16 @@ var initializeCli = async (options, context = {}) => {
         }
         provider = parseProvider(selected.provider);
         model = options.model ?? selected.model;
+        reasoningEffort = options.reasoningEffort ?? selected.reasoningEffort;
       }
     } finally {
       input.close();
     }
   }
-  const created = await (options.updateProfile ? updateCliProfile : createCliProfile)(profileName, { provider, model });
+  if (reasoningEffort && !modelReasoningEfforts(provider, model).includes(reasoningEffort)) {
+    throw new CliUsageError(`Reasoning effort ${reasoningEffort} is not declared for ${provider}/${model}. Use default or a supported level.`);
+  }
+  const created = await (options.updateProfile ? updateCliProfile : createCliProfile)(profileName, { provider, model, ...reasoningEffort ? { reasoningEffort } : {} });
   const availability = providerAvailability().find((candidate) => candidate.id === provider);
   const doctorCommand = `zhx doctor --profile ${profileName}`;
   const runCommand = `zhx --profile ${profileName} "inspect this repository"`;
@@ -1846,7 +1741,8 @@ var initializeCli = async (options, context = {}) => {
       path: created.path,
       schemaVersion: created.profile.schemaVersion,
       provider: created.profile.provider,
-      model: created.profile.model
+      model: created.profile.model,
+      reasoningEffort: created.profile.reasoningEffort ?? "default"
     },
     credential: {
       configured: availability?.configured ?? false,
@@ -1860,18 +1756,18 @@ var initializeCli = async (options, context = {}) => {
     return true;
   }
   if (context.onboarding) {
-    process.stdout.write(`Provider and model saved. Next: configure credentials for ${provider}.
+    process.stdout.write(`Provider and model saved. Reasoning: ${created.profile.reasoningEffort ?? "default"}. Next: configure credentials for ${provider}.
 `);
     return true;
   }
   process.stdout.write([
     `${options.updateProfile ? "Updated" : "Created"} personal profile ${profileName} at ${created.path}.`,
-    `Provider: ${created.profile.provider} · Model: ${created.profile.model}`,
+    `Provider: ${created.profile.provider} · Model: ${created.profile.model} · Reasoning: ${created.profile.reasoningEffort ?? "default"}`,
     availability?.configured ? "Provider credential detected; no secret value was stored or printed." : `Open zhx to configure a managed key, or set ${availability?.credentialNames.join(" or ") || "the provider credential"} for automation.`,
     "Next:",
     `  ${doctorCommand}`,
     `  ${runCommand}`,
-    "Profiles contain provider and model only. A later bare interactive console uses the default profile automatically. Change it with zhx init --update."
+    "Profiles contain provider, model and optional reasoning effort. A later bare interactive console uses the default profile automatically. Change it with zhx init --update."
   ].join(`
 `) + `
 `);
@@ -1925,6 +1821,7 @@ Options (automation and advanced configuration):
   --update                       Update an existing profile (init only)
   --provider <${PROVIDERS.join("|")}>  Provider (default: openai)
   --model <id>                   Override the default model
+  --reasoning <level>            default, none, minimal, low, medium, high, xhigh, max (model-dependent)
   --compaction-model <id>        Opt into model-assisted compaction with this model
   --compaction-provider <id>     Compaction provider (defaults to the primary provider)
   --route <role=provider[:model]> Route a subagent role; repeatable
@@ -2330,7 +2227,7 @@ This connection will replace Qwen environment settings for this CLI session.
   }
 }
 async function credentialModel(config, env, modelFactory) {
-  const { createProviderModel: createProviderModel2 } = await import("./config-w1npe8mp.js");
+  const { createProviderModel: createProviderModel2 } = await import("./config-1k9t4jhh.js");
   const { wrapLanguageModel } = await import("@zhivex-ai/core");
   const secrets = providerDescriptor(config.provider).credentialNames.map((name) => env[name]).filter((value) => !!value);
   const safeError = (error) => {
@@ -2943,6 +2840,7 @@ var consoleBudgetOptions = (options, env = process.env) => ({
 var restoreConsoleOptions = (current, saved) => ({
   ...current,
   ...saved,
+  reasoningEffort: saved.reasoningEffort ?? "default",
   unlimitedTokens: saved.unlimitedTokens ?? false
 });
 var formatConsoleBudget = (config, usage) => {
@@ -3105,8 +3003,8 @@ var manageSessions = async (options) => {
     let document;
     switch (options.sessionsCommand) {
       case "list": {
-        const summaries2 = await store.list({ ...options.limit ? { limit: options.limit } : {}, ...options.sessionSearch ? { search: options.sessionSearch } : {} });
-        const indexed = (await Promise.all(summaries2.map((summary) => store.get(summary.sessionId)))).filter((value) => Boolean(value));
+        const summaries = await store.list({ ...options.limit ? { limit: options.limit } : {}, ...options.sessionSearch ? { search: options.sessionSearch } : {} });
+        const indexed = (await Promise.all(summaries.map((summary) => store.get(summary.sessionId)))).filter((value) => Boolean(value));
         const sessions = [];
         for (const selected of indexed)
           sessions.push(await refreshDurableStatus(selected));
@@ -3448,6 +3346,7 @@ var chat = async (options) => {
   const sessionStore = await openSessionStoreForConfig(baseConfig);
   const readline = new ConsoleInput(process.stdin, process.stdout);
   const attachments = new ConsoleAttachments;
+  const activityHistory = new ActivityHistory;
   const credentials = { store: new CliCredentials, input: readline };
   let credentialsRevision = credentials.store.revision;
   let activeController;
@@ -3464,9 +3363,11 @@ Stopping the active operation; waiting for durable state and cleanup.
   const abortable = async (operation) => {
     const controller = new AbortController;
     activeController = controller;
+    readline.startBackground();
     try {
       return await operation(controller.signal);
     } finally {
+      readline.stopBackground();
       activeController = undefined;
     }
   };
@@ -3523,6 +3424,37 @@ Stopping the active operation; waiting for durable state and cleanup.
     sessionStore.close();
     throw error;
   }
+  const consoleApprovals = async (approvals, context) => {
+    readline.stopBackground();
+    try {
+      return await terminalApprovalResolver(options.approvalMode ?? options.yes, (question) => readline.question(question), { select: (title, items) => readline.select(title, items), workspace: harness.config.workspace, sessionGrants })(approvals, context);
+    } finally {
+      if (activeController && !activeController.signal.aborted)
+        readline.startBackground();
+    }
+  };
+  const createTracker = () => {
+    let offset = harness.workspace.mutationAudit().length;
+    const tracker = {
+      streamedText: false,
+      activityHistory,
+      inputStatus: () => readline.backgroundStatus
+    };
+    return { tracker, onEvent: async (event) => {
+      await streamSink({ json: false, jsonl: false }, tracker, !verbose)(event);
+      if (event.type === "tool-result") {
+        const audit = harness.workspace.mutationAudit();
+        const receipt = formatAppliedFiles(audit.slice(offset));
+        offset = audit.length;
+        if (receipt) {
+          flushToolActivity(tracker);
+          tracker.markdown?.flush();
+          process.stderr.write(receipt);
+          activityHistory.add(receipt.trim());
+        }
+      }
+    } };
+  };
   const refreshSession = async () => {
     const refreshed = await sessionStore.get(session.sessionId);
     if (!refreshed)
@@ -3568,6 +3500,7 @@ Stopping the active operation; waiting for durable state and cleanup.
     session = selected;
     attachments.clear();
     readline.clearHistory();
+    activityHistory.clear();
     messages = state?.messages ?? [];
     retainedTasks = taskSources(state?.metadata);
   };
@@ -3579,7 +3512,7 @@ Stopping the active operation; waiting for durable state and cleanup.
 `);
       return;
     }
-    const tracker = { streamedText: false };
+    const { tracker, onEvent } = createTracker();
     session = await sessionStore.updateRun(session.sessionId, state.runId, { status: "running" });
     let result;
     try {
@@ -3589,8 +3522,8 @@ Stopping the active operation; waiting for durable state and cleanup.
         abortSignal,
         approvals: approvalResponses(state.pendingApprovals, approve, approve ? "Approved inline in chat." : "Denied inline in chat.")
       }, {
-        onEvent: streamSink({ json: false, jsonl: false }, tracker, !verbose),
-        resolveApprovals: terminalApprovalResolver(options.approvalMode ?? options.yes, (question) => readline.question(question), { select: (title, items) => readline.select(title, items), workspace: harness.config.workspace, sessionGrants })
+        onEvent,
+        resolveApprovals: consoleApprovals
       }));
     } catch {
       flushToolActivity(tracker);
@@ -3640,6 +3573,8 @@ Last failure: ${terminalRunFailure(failedState.error)} (${failedState.currentSte
   }, { color: terminalSupportsColor(Boolean(process.stderr.isTTY)), columns: process.stdout.columns ?? 80 }) + `
 `);
   process.stderr.write(`Ready · credential: ${credentials.store.source(harness.config.provider)} · account access is not checked until your first task.
+`);
+  process.stderr.write(`While working: type a draft, Enter queues the next task, Up recalls the last queued task. Ctrl+C stops and clears the queue.
 `);
   process.stderr.write(options.approvalMode === "restricted" ? `Restricted mode: additional approvals are denied.
 ` : options.yes ? `Automatic approvals are enabled within workspace and execution policies.
@@ -3663,16 +3598,17 @@ ${summarizeApproval(approval)}
     await showSessionState();
     for (;; ) {
       try {
-        process.stdout.write(formatComposer({
+        const pendingTurn = await hasActiveTurn();
+        readline.setQueueEnabled(!pendingTurn);
+        const submitted = await readline.compose({
           model: `${harness.config.provider}/${harness.config.model}`,
+          reasoning: harness.config.reasoningEffort ?? "default",
           ...session.title ? { title: session.title } : {},
           status: session.runs.at(-1)?.status === "waiting_approval" ? "approval pending · /pending" : "ready",
           attachments: attachments.list().length,
           automaticApprovals: options.yes === true,
           ...options.approvalMode ? { approvalMode: options.approvalMode } : {}
-        }, process.stdout.columns));
-        const submitted = await readline.question(`
-> `, true);
+        });
         const literalInput = readline.lastSubmissionWasPaste || submitted.includes(`
 `);
         let prompt = literalInput ? submitted : submitted.trim();
@@ -3683,7 +3619,7 @@ ${summarizeApproval(approval)}
         if (["/menu", "/provider", "/providers", "/model", "/models"].includes(command)) {
           const selection = await navigateConsole(readline, {
             entry: command === "/menu" ? "menu" : command.startsWith("/provider") ? "provider" : "model",
-            current: { provider: harness.config.provider, model: harness.config.model },
+            current: { provider: harness.config.provider, model: harness.config.model, reasoningEffort: harness.config.reasoningEffort ?? "default" },
             providers: providerAvailability(),
             sessions: async () => (await sessionStore.list({ limit: 200 })).map((item) => ({ value: item.sessionId, label: item.title ?? "Untitled conversation", detail: item.sessionId }))
           });
@@ -3700,9 +3636,9 @@ ${summarizeApproval(approval)}
               continue;
             }
             const portableMessages = compactHarnessMessages(messages);
-            await replaceHarness({ ...runtimeOptions, provider: parseProvider(selection.provider), model: selection.model }, routes);
+            await replaceHarness({ ...runtimeOptions, provider: parseProvider(selection.provider), model: selection.model, reasoningEffort: selection.reasoningEffort ?? "default" }, routes);
             messages = portableMessages;
-            process.stderr.write(`Next turn: ${selection.provider}/${selection.model}; context was compacted.
+            process.stderr.write(`Next turn: ${selection.provider}/${selection.model} · reasoning ${selection.reasoningEffort ?? "default"}; context was compacted.
 `);
             continue;
           }
@@ -3841,8 +3777,8 @@ ${summarizeApproval(approval)}
           continue;
         }
         if (command === "/sessions" || command.startsWith("/sessions ")) {
-          const summaries2 = await sessionStore.list({ search: command.slice(9).trim(), limit: 200 });
-          for (const summary of summaries2) {
+          const summaries = await sessionStore.list({ search: command.slice(9).trim(), limit: 200 });
+          for (const summary of summaries) {
             const selected = await sessionStore.get(summary.sessionId);
             if (!selected)
               continue;
@@ -3850,7 +3786,7 @@ ${summarizeApproval(approval)}
             process.stdout.write(sanitizeTerminalText(`${summary.sessionId} · ${summary.title ?? "(untitled)"} · ${summary.runCount} runs · ${durable?.status ?? "empty"}`) + `
 `);
           }
-          if (!summaries2.length)
+          if (!summaries.length)
             process.stdout.write(`No sessions match in this workspace and scope.
 `);
           continue;
@@ -3891,12 +3827,30 @@ ${summarizeApproval(approval)}
           retainedTasks = [];
           attachments.clear();
           readline.clearHistory();
+          activityHistory.clear();
           process.stderr.write(`Context cleared.
 `);
           continue;
         }
         if (command === "/status") {
           process.stderr.write(`${await statusLine()}
+`);
+          continue;
+        }
+        if (command === "/activity" || command === "/activity clear") {
+          if (command.endsWith(" clear"))
+            activityHistory.clear();
+          process.stdout.write(activityHistory.render());
+          continue;
+        }
+        if (command === "/queue clear") {
+          readline.clearQueue();
+          process.stdout.write(`Queued tasks and draft cleared.
+`);
+          continue;
+        }
+        if (command === "/queue") {
+          process.stdout.write(readline.queueSummary() + `Use /queue clear to discard queued tasks.
 `);
           continue;
         }
@@ -3944,7 +3898,7 @@ ${summarizeApproval(approval)}
           const provider = parseProvider(value);
           const model = DEFAULT_PROVIDER_REGISTRY.descriptor(provider).defaultModel;
           const portableMessages = compactHarnessMessages(messages);
-          await replaceHarness({ ...runtimeOptions, provider, model }, routes);
+          await replaceHarness({ ...runtimeOptions, provider, model, reasoningEffort: "default" }, routes);
           messages = portableMessages;
           process.stderr.write(`Next turn: ${provider}/${model}; context was compacted for a safe handoff.
 `);
@@ -3959,9 +3913,28 @@ ${summarizeApproval(approval)}
             continue;
           }
           const portableMessages = compactHarnessMessages(messages);
-          await replaceHarness({ ...runtimeOptions, model: value }, routes);
+          const reasoningEffort = await chooseReasoning(readline, harness.config.provider, value);
+          if (!reasoningEffort)
+            continue;
+          await replaceHarness({ ...runtimeOptions, model: value, reasoningEffort }, routes);
           messages = portableMessages;
           process.stderr.write(`Next turn: ${harness.config.provider}/${value}; context was compacted.
+`);
+          continue;
+        }
+        if (command === "/reasoning" || command.startsWith("/reasoning ")) {
+          const active2 = await hasActiveTurn();
+          if (active2) {
+            process.stderr.write(`Cannot change reasoning while run ${active2.runId} is ${active2.status}.
+`);
+            continue;
+          }
+          const argument = command.slice("/reasoning".length).trim();
+          const effort = argument ? reasoningEffortSchema.parse(argument) : await chooseReasoning(readline, harness.config.provider, harness.config.model, harness.config.reasoningEffort);
+          if (!effort)
+            continue;
+          await replaceHarness({ ...runtimeOptions, reasoningEffort: effort }, routes);
+          process.stderr.write(`Reasoning for next turns: ${effort}.
 `);
           continue;
         }
@@ -4119,7 +4092,7 @@ ${sanitizeTerminalText(prompt)}
           status: "created"
         });
         const turn = session.runs.at(-1);
-        const tracker = { streamedText: false };
+        const { tracker, onEvent } = createTracker();
         const progress = consoleProgressGuard();
         let markedRunning = false;
         let result;
@@ -4167,9 +4140,9 @@ ${sanitizeTerminalText(prompt)}
                 session = await sessionStore.updateRun(session.sessionId, runId, { status: "running" });
                 markedRunning = true;
               }
-              await streamSink({ json: false, jsonl: false }, tracker, !verbose)(event);
+              await onEvent(event);
             },
-            resolveApprovals: terminalApprovalResolver(options.approvalMode ?? options.yes, (question) => readline.question(question), { select: (title, items) => readline.select(title, items), workspace: harness.config.workspace, sessionGrants })
+            resolveApprovals: consoleApprovals
           }));
         } catch (error) {
           flushToolActivity(tracker);
@@ -4597,6 +4570,175 @@ var manageChanges = async (options) => {
     process.exitCode = CLI_EXIT_CODES.runtimeError;
 };
 
+// src/persistence/state-backup-stream.ts
+var MAGIC = `ZHIVEX-STATE-SEGMENTS-1
+`;
+var STRING_CHARS = 8192;
+var MAX_FRAME_BYTES = 64 * 1024;
+function* canonicalChunks(value) {
+  if (typeof value === "string") {
+    yield '"';
+    for (let i = 0;i < value.length; ) {
+      let end = Math.min(i + STRING_CHARS, value.length);
+      if (end < value.length && /[\uD800-\uDBFF]/.test(value[end - 1]))
+        end--;
+      yield JSON.stringify(value.slice(i, end)).slice(1, -1);
+      i = end;
+    }
+    yield '"';
+  } else if (value === null || typeof value !== "object") {
+    yield JSON.stringify(value);
+  } else if (Array.isArray(value)) {
+    yield "[";
+    for (let i = 0;i < value.length; i++) {
+      if (i)
+        yield ",";
+      yield* canonicalChunks(value[i]);
+    }
+    yield "]";
+  } else {
+    yield "{";
+    let first = true;
+    for (const key of Object.keys(value).sort()) {
+      if (!first)
+        yield ",";
+      first = false;
+      yield* canonicalChunks(key);
+      yield ":";
+      yield* canonicalChunks(value[key]);
+    }
+    yield "}";
+  }
+}
+function* tokens(value) {
+  if (typeof value === "string") {
+    for (let i = 0;i < value.length; i += STRING_CHARS)
+      yield ["text", value.slice(i, i + STRING_CHARS)];
+    yield ["string"];
+  } else if (value === null || typeof value !== "object")
+    yield ["value", value];
+  else {
+    yield [Array.isArray(value) ? "array" : "object"];
+    if (Array.isArray(value))
+      for (const item of value)
+        yield* tokens(item);
+    else
+      for (const [key, item] of Object.entries(value)) {
+        yield* tokens(key);
+        yield* tokens(item);
+      }
+    yield ["end"];
+  }
+}
+function* segmentedChunks(value) {
+  yield MAGIC;
+  for (const token of tokens(value))
+    yield `${JSON.stringify(token)}
+`;
+}
+async function readBackupTransport(source, legacyMaxBytes) {
+  const fail = () => {
+    throw new Error("Harness state backup segment stream is invalid or incomplete.");
+  };
+  const stack = [];
+  let root;
+  let hasRoot = false;
+  let pieces = [];
+  let pending = Buffer.alloc(0);
+  let segmented;
+  const legacy = [];
+  let legacyBytes = 0;
+  const append = (value) => {
+    const parent = stack.at(-1);
+    if (!parent) {
+      if (hasRoot)
+        fail();
+      root = value;
+      hasRoot = true;
+    } else if (Array.isArray(parent.value))
+      parent.value.push(value);
+    else if (parent.key === undefined) {
+      if (typeof value !== "string" || Object.hasOwn(parent.value, value))
+        fail();
+      parent.key = value;
+    } else {
+      Object.defineProperty(parent.value, parent.key, { value, enumerable: true, writable: true, configurable: true });
+      delete parent.key;
+    }
+  };
+  const consume = (line) => {
+    if (line.length > MAX_FRAME_BYTES)
+      fail();
+    const token = JSON.parse(line.toString("utf8"));
+    if (!Array.isArray(token))
+      fail();
+    const frame = token;
+    const [kind, value] = frame;
+    if (kind === "text" && frame.length === 2 && typeof value === "string") {
+      pieces.push(value);
+      return;
+    }
+    if (kind === "string" && frame.length === 1) {
+      append(pieces.join(""));
+      pieces = [];
+      return;
+    }
+    if (pieces.length)
+      fail();
+    if (kind === "value" && frame.length === 2 && (value === null || typeof value === "boolean" || typeof value === "number"))
+      append(value);
+    else if ((kind === "array" || kind === "object") && frame.length === 1) {
+      if (stack.length >= 512)
+        fail();
+      const value2 = kind === "array" ? [] : {};
+      append(value2);
+      stack.push({ value: value2 });
+    } else if (kind === "end" && frame.length === 1) {
+      const parent = stack.pop();
+      if (!parent || parent.key !== undefined)
+        fail();
+    } else
+      fail();
+  };
+  for await (const chunk of readRegularFileChunksNoFollow(source, {
+    label: "Harness state backup",
+    requireSingleLink: true,
+    requirePrivate: true
+  })) {
+    pending = Buffer.concat([pending, chunk]);
+    if (segmented === undefined) {
+      if (pending.length < Buffer.byteLength(MAGIC))
+        continue;
+      segmented = pending.subarray(0, MAGIC.length).toString() === MAGIC;
+      if (segmented)
+        pending = pending.subarray(MAGIC.length);
+    }
+    if (!segmented) {
+      legacyBytes += pending.length;
+      if (legacyBytes > legacyMaxBytes)
+        throw new Error("Harness state backup exceeds the legacy size limit.");
+      legacy.push(pending);
+      pending = Buffer.alloc(0);
+      continue;
+    }
+    let newline;
+    while ((newline = pending.indexOf(10)) !== -1) {
+      consume(pending.subarray(0, newline));
+      pending = pending.subarray(newline + 1);
+    }
+    if (pending.length > MAX_FRAME_BYTES)
+      fail();
+  }
+  if (!segmented) {
+    if (legacyBytes + pending.length > legacyMaxBytes)
+      throw new Error("Harness state backup exceeds the legacy size limit.");
+    return JSON.parse(Buffer.concat([...legacy, pending]).toString("utf8"));
+  }
+  if (pending.length || stack.length || pieces.length || !hasRoot)
+    fail();
+  return root;
+}
+
 // src/persistence/workspace-checkpoints.ts
 import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
 import { z as z3 } from "zod";
@@ -4628,6 +4770,7 @@ import { chmod, link, lstat as lstat3, open as open2, realpath, unlink as unlink
 import path5 from "node:path";
 import { z as z4 } from "zod";
 import { normalizeAgentRunState } from "@zhivex-ai/agents";
+import { createSqliteAgentRunStore } from "@zhivex-ai/agents/ops";
 var HARNESS_STATE_BACKUP_SCHEMA_VERSION = 1;
 var HARNESS_STATE_BACKUP_MAX_BYTES = 64 * 1024 * 1024;
 var terminalRunStatuses = new Set(["completed", "failed", "cancelled", "timed_out"]);
@@ -4762,7 +4905,12 @@ var canonicalJson = (value) => {
     return `[${value.map(canonicalJson).join(",")}]`;
   return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
 };
-var checksumPayload = (payload) => `sha256:${createHash3("sha256").update(canonicalJson(payload)).digest("hex")}`;
+var checksumPayload = (payload) => {
+  const hash = createHash3("sha256");
+  for (const chunk of canonicalChunks(payload))
+    hash.update(chunk);
+  return `sha256:${hash.digest("hex")}`;
+};
 var stableKey = (kind, value) => createHash3("sha256").update(kind).update("\x00").update(value).digest("hex");
 var scopeValue = (config) => `${config.scope.tenantId}\x00${config.scope.userId ?? ""}\x00${config.scope.namespace ?? ""}`;
 var scopePrefix = (config) => `${encodeURIComponent(config.scope.namespace ?? "default")}:${encodeURIComponent(config.scope.tenantId)}:${encodeURIComponent(config.scope.userId ?? "*")}:`;
@@ -4794,8 +4942,8 @@ var validateBudgetLedger = (config, run, identities) => {
     if (!/^sha256:[a-f0-9]{64}$/.test(id) || !value || typeof value !== "object" || Array.isArray(value) || value.status !== "confirmed") {
       throw new HarnessStateConflictError("Budget ledger retains unresolved reservations or unknown consumption.");
     }
-    const tokens = value.tokens;
-    if (!tokens || typeof tokens !== "object" || Array.isArray(tokens) || ![tokens.inputTokens, tokens.outputTokens, tokens.totalTokens].every((amount) => typeof amount === "number" && Number.isSafeInteger(amount) && amount >= 0) || tokens.totalTokens < tokens.inputTokens + tokens.outputTokens) {
+    const tokens2 = value.tokens;
+    if (!tokens2 || typeof tokens2 !== "object" || Array.isArray(tokens2) || ![tokens2.inputTokens, tokens2.outputTokens, tokens2.totalTokens].every((amount) => typeof amount === "number" && Number.isSafeInteger(amount) && amount >= 0) || tokens2.totalTokens < tokens2.inputTokens + tokens2.outputTokens) {
       throw new HarnessStateConflictError("Invalid budget ledger token receipt.");
     }
   }
@@ -4897,8 +5045,13 @@ var readPayload = async (config, recordedWorkspace, accessLease) => {
     if (recordedWorkspace && database.query("SELECT version FROM zhivex_cli_session_schema WHERE singleton=1").get()?.version !== HARNESS_SESSION_SCHEMA_VERSION)
       throw new HarnessStateConflictError("Archived session schema is incompatible.");
     const allRunRows = database.query("SELECT run_id, state_json, updated_at_ms FROM zhivex_agent_runs ORDER BY run_id").all();
+    let historyReader;
     const runRows = allRunRows.flatMap((row) => {
-      const state = validatedRunState(parseJsonRecord(row.state_json, `Run ${row.run_id}`), `Run ${row.run_id}`);
+      const record = parseJsonRecord(row.state_json, `Run ${row.run_id}`);
+      const hydrated = record.checkpointHistory ? (historyReader ??= createSqliteAgentRunStore({ db: sqliteAdapter(database), history: "incremental" })).load(String(record.runId), record.scope) : record;
+      if (hydrated instanceof Promise || !hydrated)
+        throw new HarnessStateConflictError("Cannot hydrate state backup history.");
+      const state = validatedRunState(hydrated, `Run ${row.run_id}`);
       return stateMatchesScope(config, state) ? [{ row, state }] : [];
     });
     const runs = runRows.map(({ row, state }) => {
@@ -5058,7 +5211,19 @@ var writePrivateBackup = async (target, contents) => {
   try {
     handle = await open2(staged, fsConstants3.O_WRONLY | fsConstants3.O_CREAT | fsConstants3.O_EXCL | fsConstants3.O_NOFOLLOW, 384);
     stagedExists = true;
-    await handle.writeFile(contents, "utf8");
+    let pending = [];
+    let pendingBytes = 0;
+    for (const chunk of contents) {
+      pending.push(chunk);
+      pendingBytes += Buffer.byteLength(chunk);
+      if (pendingBytes >= 64 * 1024) {
+        await handle.writeFile(pending.join(""), "utf8");
+        pending = [];
+        pendingBytes = 0;
+      }
+    }
+    if (pending.length)
+      await handle.writeFile(pending.join(""), "utf8");
     await handle.sync();
     await chmod(staged, 384);
     await handle.close();
@@ -5085,12 +5250,13 @@ var writePrivateBackup = async (target, contents) => {
 };
 var exportHarnessStateBackup = async (config, target) => {
   const bundle = await createHarnessStateBackup(config);
-  const serialized = `${JSON.stringify(bundle, null, 2)}
-`;
-  if (Buffer.byteLength(serialized) > HARNESS_STATE_BACKUP_MAX_BYTES) {
-    throw new HarnessStateConflictError("State backup exceeds the supported size limit.");
+  let bytes = 0;
+  for (const chunk of canonicalChunks(bundle)) {
+    bytes += Buffer.byteLength(chunk);
+    if (bytes > HARNESS_STATE_BACKUP_MAX_BYTES)
+      break;
   }
-  await writePrivateBackup(target, serialized);
+  await writePrivateBackup(target, bytes > HARNESS_STATE_BACKUP_MAX_BYTES ? segmentedChunks(bundle) : canonicalChunks(bundle));
   return {
     schemaVersion: HARNESS_STATE_BACKUP_SCHEMA_VERSION,
     kind: "state-export",
@@ -5100,19 +5266,14 @@ var exportHarnessStateBackup = async (config, target) => {
   };
 };
 var readHarnessStateBackup = async (source) => {
-  const { contents, stat: stat2 } = await readRegularFileNoFollow(path5.resolve(source), {
-    label: "Harness state backup",
-    maxBytes: HARNESS_STATE_BACKUP_MAX_BYTES,
-    requireSingleLink: true
-  });
-  if ((stat2.mode & 63) !== 0) {
-    throw new HarnessWorkspaceError("Harness state backup permissions must not grant group or other access.");
-  }
   let input;
   try {
-    input = JSON.parse(contents.toString("utf8"));
+    input = await readBackupTransport(path5.resolve(source), HARNESS_STATE_BACKUP_MAX_BYTES);
   } catch (error) {
-    throw new HarnessStateConflictError("Harness state backup is not valid JSON.", { cause: error });
+    if (error instanceof SyntaxError) {
+      throw new HarnessStateConflictError("Harness state backup is not valid JSON.", { cause: error });
+    }
+    throw error;
   }
   return validateStateBackupBundle(input);
 };
@@ -5513,7 +5674,7 @@ var main = async (argv = process.argv.slice(2)) => {
     parsedOptions = { ...parsedOptions, prompt: await readStdinTask() };
   }
   if (parsedOptions.serviceFile) {
-    const { runServiceCli } = await import("./service-client-cli-1c9j6xah.js");
+    const { runServiceCli } = await import("./service-client-cli-yx56n0hc.js");
     await runServiceCli(parsedOptions, annotateCliStreamError);
     return;
   }