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

package/dist/{cli-7nj89dq0.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-hkxakkng.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,103 +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 dependency types",
-  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: "reads",
-  search_files: "searches",
-  search_many: "searches",
-  list_files: "listings",
-  apply_patch: "edits",
-  apply_reviewed_edits: "edits",
-  apply_reviewed_replacement: "edits",
-  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_")) {
-      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;
-  }
-  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();
-  }
-}
-
 // src/cli/terminal/terminal-table.ts
 var segments = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 var graphemes = (value) => [...segments.segment(value)].map((item) => item.segment);
@@ -1395,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,
@@ -1549,74 +1468,21 @@ var approvalResponses = (approvals, approve, reason) => approvals.map((approval)
   reason
 }));
 var terminalApprovalResolver = (automaticallyApprove, ask, ui) => {
-  const grants = new Set;
   return async (approvals) => {
     if (automaticallyApprove === "restricted")
       return approvalResponses(approvals, false, "Denied by restricted approval mode.");
-    if ((automaticallyApprove === true || automaticallyApprove === "auto") && !approvals.some((a) => a.name === "read_dependency")) {
-      return approvalResponses(approvals, true, "Approved by --yes.");
+    if (automaticallyApprove === true || automaticallyApprove === "auto") {
+      return approvalResponses(approvals, true, "Approved by automatic mode.");
     }
-    if (!ask && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+    if (!ask && (!process.stdin.isTTY || !process.stdout.isTTY))
       return;
-    }
     const readline = ask ? undefined : createInterface({ input: process.stdin, output: process.stdout });
-    const question = ask ?? ((text) => readline.question(text));
     try {
-      if (!approvals.some((a) => a.name === "read_dependency")) {
-        return await resolveTerminalApprovals(approvals, { ask: question, write: (text) => process.stderr.write(text), ...ui });
-      }
-      const responses = [];
-      const staged = new Set(grants);
-      const stagedSession = ui?.sessionGrants ? new Set(ui.sessionGrants) : undefined;
-      for (const approval of approvals) {
-        if (approval.name === "read_dependency") {
-          let name;
-          try {
-            const args = typeof approval.arguments === "string" ? JSON.parse(approval.arguments) : approval.arguments;
-            if (args && typeof args.package === "string" && /^(?:@[a-z0-9_-]+\/)?[a-z0-9][a-z0-9._-]*$/.test(args.package))
-              name = args.package;
-          } catch {}
-          const key = name ? JSON.stringify([approval.provider, approval.childAgentId ?? "", name]) : undefined;
-          const sessionKey = key && ui?.workspace ? JSON.stringify(["dependency", ui.workspace, key]) : undefined;
-          if (sessionKey && stagedSession?.has(sessionKey)) {
-            responses.push(...approvalResponses([approval], true, "Dependency metadata/types approved for this CLI session."));
-            continue;
-          }
-          if (key && staged.has(key)) {
-            responses.push(...approvalResponses([approval], true, "Dependency read approved for this task."));
-            continue;
-          }
-          process.stderr.write(formatApproval(approval, { detail: "summary" }) + `
-`);
-          const answer = ui ? await ui.select(`Dependency metadata/types: ${name ?? "invalid package"}`, [
-            { value: "n", label: "Reject" },
-            { value: "y", label: "Allow once" },
-            { value: "t", label: "Allow this package for this task", detail: "Metadata and type declarations only" },
-            ...stagedSession ? [{ value: "s", label: "Allow this package for this session", detail: "Metadata and type declarations only" }] : [],
-            { value: "q", label: "Leave pending" }
-          ]) ?? "q" : (await question(`Read dependency ${name ?? "(invalid package)"} metadata/types? [y] once / [t] this task / [n] deny / [q] leave pending: `)).trim().toLowerCase();
-          if (answer === "q")
-            return;
-          const approved = Boolean(key && (["y", "yes", "t"].includes(answer) || answer === "s" && stagedSession && sessionKey));
-          if (approved && answer === "t")
-            staged.add(key);
-          if (approved && answer === "s" && sessionKey)
-            stagedSession?.add(sessionKey);
-          responses.push(...approvalResponses([approval], approved, approved ? "Approved bounded dependency read." : "Dependency read denied."));
-        } else if (automaticallyApprove === true || automaticallyApprove === "auto") {
-          responses.push(...approvalResponses([approval], true, "Approved by automatic mode."));
-        } else {
-          const result = await resolveTerminalApprovals([approval], { ask: question, write: (text) => process.stderr.write(text), ...ui, ...stagedSession ? { sessionGrants: stagedSession } : {} });
-          if (!result)
-            return;
-          responses.push(...result);
-        }
-      }
-      for (const key of staged)
-        grants.add(key);
-      for (const key of stagedSession ?? [])
-        ui?.sessionGrants?.add(key);
-      return responses;
+      return await resolveTerminalApprovals(approvals, {
+        ask: ask ?? ((text) => readline.question(text)),
+        write: (text) => process.stderr.write(text),
+        ...ui
+      });
     } finally {
       readline?.close();
     }
@@ -1668,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)}
@@ -1681,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") {
@@ -1721,16 +1589,40 @@ var streamSink = (output, tracker, compact = false) => async (event) => {
     }
     if (event.type === "tool-result") {
       activity.finish(event.toolResult.toolName, !event.toolResult.isError);
-      if (!event.toolResult.isError && !["run_check", "run_environment_command"].includes(event.toolResult.toolName) && !event.toolResult.toolName.startsWith("verify_and_apply_"))
+      const detail = compactToolResult(event.toolResult);
+      const check = ["run_check", "run_environment_command"].includes(event.toolResult.toolName) || event.toolResult.toolName.startsWith("verify_and_apply_");
+      if (detail && !check) {
+        activity.pause();
+        tracker.markdown?.flush();
+        if (proseLineOpen.has(tracker)) {
+          process.stdout.write(`
+`);
+          proseLineOpen.delete(tracker);
+        }
+        process.stderr.write(`${detail}
+`);
+        return;
+      }
+      if (!check)
         return;
+      activity.pause();
+    } else if (["agent-run-finish", "error", "tool-approval-request", "agent-approval-request"].includes(event.type)) {
+      tracker.markdown?.flush();
+      if (proseLineOpen.has(tracker)) {
+        process.stdout.write(`
+`);
+        proseLineOpen.delete(tracker);
+      }
       activity.flush();
     } else if (!["provider-data", "finish", "agent-step-start", "agent-step-finish"].includes(event.type)) {
-      activity.flush();
+      activity.pause();
     }
   }
   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);
@@ -1757,9 +1649,12 @@ Zhivex
       return;
     tracker.markdown?.flush();
     proseLineOpen.delete(tracker);
-    const line = formatTerminalEvent(event, {
+    let line = formatTerminalEvent(event, {
       color: terminalSupportsColor(Boolean(process.stderr.isTTY))
     });
+    if (compact && event.type === "tool-result" && event.toolResult.isError && line?.endsWith(" · error")) {
+      line = compactToolResult(event.toolResult);
+    }
     if ((event.type === "error" || event.type === "agent-run-finish" && event.status === "failed") && line) {
       const cause = terminalRunFailure(event.type === "error" ? event.error : event.state.error);
       if (lastTerminalFailures.get(tracker) === cause)
@@ -1803,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 {
@@ -1811,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 () => []
         });
@@ -1822,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"`;
@@ -1839,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,
@@ -1853,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(`
 `) + `
 `);
@@ -1918,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
@@ -2323,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) => {
@@ -2936,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) => {
@@ -3098,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));
@@ -3441,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;
@@ -3457,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;
     }
   };
@@ -3516,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)
@@ -3561,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);
   };
@@ -3572,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 {
@@ -3582,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);
@@ -3633,9 +3573,11 @@ 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; dependency access still requires permission.
+` : options.yes ? `Automatic approvals are enabled within workspace and execution policies.
 ` : `Changes require your approval.
 `);
   const showSessionState = async () => {
@@ -3656,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();
@@ -3676,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 }))
           });
@@ -3693,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;
           }
@@ -3834,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;
@@ -3843,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;
@@ -3884,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;
         }
@@ -3937,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.
 `);
@@ -3952,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;
         }
@@ -4112,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;
@@ -4160,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);
@@ -4590,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";
@@ -4621,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"]);
@@ -4755,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 ?? "*")}:`;
@@ -4787,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.");
     }
   }
@@ -4890,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 }) => {
@@ -5051,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();
@@ -5078,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",
@@ -5093,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);
 };
@@ -5506,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-s3ee2hrj.js");
+    const { runServiceCli } = await import("./service-client-cli-yx56n0hc.js");
     await runServiceCli(parsedOptions, annotateCliStreamError);
     return;
   }