@zhivex-ai/harness 1.2.0-rc.12 → 1.2.0-rc.13

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to Zhivex Harness are documented in this file.
 
 The project follows Semantic Versioning. During `0.x`, minor releases may change user-facing contracts when the change is documented with a migration note. Patch releases remain backwards compatible bug fixes.
 
+## 1.2.0-rc.13 - 2026-09-26
+
+- Store SQLite run history incrementally with published Core 1.26.0 and Agents 1.10.1. Keep the 4 MiB limit on the active checkpoint while retaining steps, tool results and compaction history separately; unchanged history is not rewritten.
+- Export backups above 64 MiB through a bounded, versioned segment stream, preserving legacy JSON imports, checksums and atomic publication.
+- Preserve full history through reopen and portable backup/restore, including legacy inline states. Report state-limit failures with bounded diagnostics and retain the SDK terminal failure checkpoint.
+- Add a 200-read, 99-compaction regression covering more than 11 MB of hydrated history with a checkpoint below 48 KB. Full hydrated loads and disk retention remain proportional to history size.
+- Prepare fresh exact-artifact, live and representative certification for RC13; RC12 publication evidence remains historical.
+
 ## 1.2.0-rc.12 - 2026-09-26
 
 - Preserve optional edit/retry fields in OpenAI Responses tool schemas; keep runtime validation, read-bound digests and approval checks unchanged.

package/README.md

@@ -11,12 +11,12 @@ implement a change. Conversation context retains decisions, hypotheses and bound
 diagnostic excerpts across compaction. Edits and command execution keep their
 own permission checks; a conversational summary never grants approval.
 
-Version `1.2.0-rc.12` is prepared as an unpublished release candidate for npm `next`,
-with task continuity, dependency inspection and quieter console progress improvements. Certification
+Version `1.2.0-rc.13` is prepared as an unpublished release candidate for npm `next`,
+with incremental durable history and bounded active checkpoints for long conversations. Certification
 and publication remain pending. The
 [repository release status](https://raw.githubusercontent.com/Zhivex/zhivex-harness/main/release-status.json)
 preserves historical stable evidence. The installation commands below target
-1.2.0-rc.12 once published; stable users can install `@zhivex-ai/harness@latest`.
+1.2.0-rc.13 once published; stable users can install `@zhivex-ai/harness@latest`.
 Desktop retains its separate private alpha status.
 
 ## Quick start
@@ -24,7 +24,7 @@ Desktop retains its separate private alpha status.
 Requires Node.js 22.13.0 or newer, Git and a provider API key.
 
 ```sh
-npm install -g @zhivex-ai/harness@1.2.0-rc.12
+npm install -g @zhivex-ai/harness@1.2.0-rc.13
 cd /path/to/your/project
 zhx
 ```

package/dist/acp-cli.js

@@ -2484,6 +2484,31 @@ var readRegularFileNoFollow = async (target, options) => {
     await handle.close();
   }
 };
+async function* readRegularFileChunksNoFollow(target, options) {
+  const handle = await openRegularFileNoFollow(target, options.label);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || options.requireSingleLink && before.nlink !== 1)
+      throw invalidFileError(options.label);
+    if (options.requirePrivate && (before.mode & 63) !== 0)
+      throw new Error(`${options.label} permissions must not grant group or other access.`);
+    let offset = 0;
+    while (offset < before.size) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - offset));
+      const { bytesRead: bytesRead2 } = await handle.read(buffer, 0, buffer.length, offset);
+      if (!bytesRead2)
+        throw new FileChangedWhileReadingError(options.label);
+      offset += bytesRead2;
+      yield buffer.subarray(0, bytesRead2);
+    }
+    const probe = Buffer.allocUnsafe(1);
+    const { bytesRead } = await handle.read(probe, 0, 1, offset);
+    if (bytesRead || !sameOpenFile(before, await handle.stat()))
+      throw new FileChangedWhileReadingError(options.label);
+  } finally {
+    await handle.close();
+  }
+}
 
 // src/cli/cli-profiles.ts
 var CLI_PROFILE_SCHEMA_VERSION = 1;
@@ -11786,7 +11811,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     database.exec("PRAGMA foreign_keys = ON");
     await chmod3(databasePath, 384);
     const databaseLike = sqliteAdapter(database);
-    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
     const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
     const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
     return {
@@ -14855,6 +14880,9 @@ var terminalRunFailure = (error) => {
   const streamOverflow = /^Stream replay buffer exceeded its limit of (\d+) events\.$/.exec(message);
   if (streamOverflow)
     return `event replay limit reached · ${streamOverflow[1]} events`;
+  const stateOverflow = /^Agent run state is (\d+) bytes and exceeds maxStateBytes=(\d+)\. Offload large tool outputs to artifacts or raise the explicit limit\.$/.exec(message);
+  if (stateOverflow)
+    return `durable state limit reached · ${stateOverflow[1]} / ${stateOverflow[2]} bytes · inspect /status before /continue`;
   if (/^Tool is not registered \(sha256:[a-f0-9]{64}\)\.$/.test(message)) {
     return "requested tool is not registered · use an available tool with its exact name";
   }

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

@@ -57,6 +57,7 @@ import {
   navigateConsole,
   openCliSessionStore,
   openHarnessPersistence,
+  readRegularFileChunksNoFollow,
   readRegularFileNoFollow,
   resolvePackageManager,
   resolveTerminalApprovals,
@@ -67,6 +68,7 @@ import {
   sanitizeTerminalText,
   serializeStreamEvent,
   serializeStreamResult,
+  sqliteAdapter,
   taskSources,
   terminalContinuationMessages,
   terminalRunFailure,
@@ -75,7 +77,7 @@ import {
   validateStateDirectory,
   verifyChangeEnvelope,
   workspaceFilePathSchema
-} from "./cli-entry-b0dtz99m.js";
+} from "./cli-entry-c2f58zj2.js";
 import {
   BUN_ENGINE_RANGE,
   HARNESS_VERSION,
@@ -4568,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";
@@ -4599,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"]);
@@ -4733,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 ?? "*")}:`;
@@ -4765,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.");
     }
   }
@@ -4868,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 }) => {
@@ -5029,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();
@@ -5056,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",
@@ -5071,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);
 };
@@ -5484,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-50sympxb.js");
+    const { runServiceCli } = await import("./service-client-cli-yx56n0hc.js");
     await runServiceCli(parsedOptions, annotateCliStreamError);
     return;
   }

package/dist/{cli-entry-b0dtz99m.js → cli-entry-c2f58zj2.js}

@@ -2075,6 +2075,9 @@ var terminalRunFailure = (error) => {
   const streamOverflow = /^Stream replay buffer exceeded its limit of (\d+) events\.$/.exec(message);
   if (streamOverflow)
     return `event replay limit reached · ${streamOverflow[1]} events`;
+  const stateOverflow = /^Agent run state is (\d+) bytes and exceeds maxStateBytes=(\d+)\. Offload large tool outputs to artifacts or raise the explicit limit\.$/.exec(message);
+  if (stateOverflow)
+    return `durable state limit reached · ${stateOverflow[1]} / ${stateOverflow[2]} bytes · inspect /status before /continue`;
   if (/^Tool is not registered \(sha256:[a-f0-9]{64}\)\.$/.test(message)) {
     return "requested tool is not registered · use an available tool with its exact name";
   }
@@ -3503,6 +3506,31 @@ var readRegularFileNoFollow = async (target, options) => {
     await handle.close();
   }
 };
+async function* readRegularFileChunksNoFollow(target, options) {
+  const handle = await openRegularFileNoFollow(target, options.label);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || options.requireSingleLink && before.nlink !== 1)
+      throw invalidFileError(options.label);
+    if (options.requirePrivate && (before.mode & 63) !== 0)
+      throw new Error(`${options.label} permissions must not grant group or other access.`);
+    let offset = 0;
+    while (offset < before.size) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - offset));
+      const { bytesRead: bytesRead2 } = await handle.read(buffer, 0, buffer.length, offset);
+      if (!bytesRead2)
+        throw new FileChangedWhileReadingError(options.label);
+      offset += bytesRead2;
+      yield buffer.subarray(0, bytesRead2);
+    }
+    const probe = Buffer.allocUnsafe(1);
+    const { bytesRead } = await handle.read(probe, 0, 1, offset);
+    if (bytesRead || !sameOpenFile(before, await handle.stat()))
+      throw new FileChangedWhileReadingError(options.label);
+  } finally {
+    await handle.close();
+  }
+}
 
 // src/integrations/mcp.ts
 import { lstat as lstat5, realpath as realpath2 } from "node:fs/promises";
@@ -9347,7 +9375,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     database.exec("PRAGMA foreign_keys = ON");
     await chmod3(databasePath, 384);
     const databaseLike = sqliteAdapter(database);
-    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
     const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
     const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
     return {
@@ -13571,4 +13599,4 @@ var verifyChangeEnvelope = (input, options = {}) => {
   };
 };
 
-export { UnsafeFileTypeError, FileSizeLimitError, FileChangedWhileReadingError, readRegularFileNoFollow, ToolActivity, compactToolResult, SqliteDatabase, validateStateDirectory, HARNESS_SESSION_SCHEMA_VERSION, openCliSessionStore, inspectRuntimeDiagnostics, USAGE_LEDGER_KEY, usagePricingSchema, inspectUsageLedger, formatUsageLedger, CLI_JSON_SCHEMA_VERSION, CLI_EVENT_SCHEMA_VERSION, serializeStreamEvent, serializeStreamResult, runResultDocument, sanitizeTerminalText, formatApproval, resolveTerminalApprovals, terminalSupportsColor, formatVerificationSummary, terminalRunFailure, formatTerminalEvent, formatConsoleHelp, ConsoleInput, chooseReasoning, loadModelCatalog, navigateConsole, loadHarnessMcpConfiguration, resolvePackageManager, fileDigestSchema, workspaceFilePathSchema, runPortableProcess, Workspace, CliOciRuntimeAdapter, cleanupHarnessExecutionArtifacts, DEFAULT_HARNESS_CONTEXT_MANIFEST, MAX_HARNESS_CONTEXT_FILE_BYTES, MAX_HARNESS_CONTEXT_TOTAL_BYTES, loadHarnessProjectContext, ActivityHistory, formatAppliedFiles, harnessToolExecution, terminalContinuationMessages, TASK_SOURCE_KEY, taskSources, formatConsoleWelcome, estimateMessages, HARNESS_SQLITE_FILE, HARNESS_OPERATIONS_SCHEMA_VERSION, listHarnessRuns, inspectHarnessRun, cancelHarnessRun, cleanupHarnessRuns, openHarnessPersistence, runHarnessReviewGroup, compactHarnessMessages, createHarness, runHarness, appendUserMessage, changeEnvelopeSchema, digestChangeEnvelopeArtifact, createChangeEnvelope, canonicalizeChangeEnvelope, changeEnvelopePreconditionsSchema, verifyChangeEnvelope };
+export { UnsafeFileTypeError, FileSizeLimitError, FileChangedWhileReadingError, readRegularFileNoFollow, readRegularFileChunksNoFollow, ToolActivity, compactToolResult, SqliteDatabase, validateStateDirectory, HARNESS_SESSION_SCHEMA_VERSION, openCliSessionStore, inspectRuntimeDiagnostics, USAGE_LEDGER_KEY, usagePricingSchema, inspectUsageLedger, formatUsageLedger, CLI_JSON_SCHEMA_VERSION, CLI_EVENT_SCHEMA_VERSION, serializeStreamEvent, serializeStreamResult, runResultDocument, sanitizeTerminalText, formatApproval, resolveTerminalApprovals, terminalSupportsColor, formatVerificationSummary, terminalRunFailure, formatTerminalEvent, formatConsoleHelp, ConsoleInput, chooseReasoning, loadModelCatalog, navigateConsole, loadHarnessMcpConfiguration, resolvePackageManager, fileDigestSchema, workspaceFilePathSchema, runPortableProcess, Workspace, CliOciRuntimeAdapter, cleanupHarnessExecutionArtifacts, DEFAULT_HARNESS_CONTEXT_MANIFEST, MAX_HARNESS_CONTEXT_FILE_BYTES, MAX_HARNESS_CONTEXT_TOTAL_BYTES, loadHarnessProjectContext, ActivityHistory, formatAppliedFiles, harnessToolExecution, terminalContinuationMessages, TASK_SOURCE_KEY, taskSources, formatConsoleWelcome, estimateMessages, HARNESS_SQLITE_FILE, HARNESS_OPERATIONS_SCHEMA_VERSION, listHarnessRuns, inspectHarnessRun, cancelHarnessRun, cleanupHarnessRuns, sqliteAdapter, openHarnessPersistence, runHarnessReviewGroup, compactHarnessMessages, createHarness, runHarness, appendUserMessage, changeEnvelopeSchema, digestChangeEnvelopeArtifact, createChangeEnvelope, canonicalizeChangeEnvelope, changeEnvelopePreconditionsSchema, verifyChangeEnvelope };

package/dist/cli.js

@@ -18,6 +18,6 @@ if (argv.length === 1 && ["--version", "-v", "version"].includes(argv[0])) {
   process.stdout.write(`${shortCliHelp(HARNESS_VERSION)}
 `);
 } else {
-  const { runCli } = await import("./cli-3qwxrh91.js");
+  const { runCli } = await import("./cli-3jmy4h5h.js");
   await runCli(argv);
 }

package/dist/hostile-repository-demo.js

@@ -10397,7 +10397,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     database.exec("PRAGMA foreign_keys = ON");
     await chmod3(databasePath, 384);
     const databaseLike = sqliteAdapter(database);
-    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
     const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
     const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
     return {

package/dist/index.js

@@ -3885,6 +3885,9 @@ var terminalRunFailure = (error) => {
   const streamOverflow = /^Stream replay buffer exceeded its limit of (\d+) events\.$/.exec(message);
   if (streamOverflow)
     return `event replay limit reached · ${streamOverflow[1]} events`;
+  const stateOverflow = /^Agent run state is (\d+) bytes and exceeds maxStateBytes=(\d+)\. Offload large tool outputs to artifacts or raise the explicit limit\.$/.exec(message);
+  if (stateOverflow)
+    return `durable state limit reached · ${stateOverflow[1]} / ${stateOverflow[2]} bytes · inspect /status before /continue`;
   if (/^Tool is not registered \(sha256:[a-f0-9]{64}\)\.$/.test(message)) {
     return "requested tool is not registered · use an available tool with its exact name";
   }
@@ -4899,11 +4902,6 @@ var openCliSessionStore = async (options) => {
   return store;
 };
 var openSessionStore = openCliSessionStore;
-// src/persistence/workspace-checkpoints.ts
-import { createHash as createHash7, randomUUID as randomUUID2 } from "node:crypto";
-import path9 from "node:path";
-import { z as z6 } from "zod";
-
 // src/workspace/file-security.ts
 import { constants as fsConstants } from "node:fs";
 import { open as open3 } from "node:fs/promises";
@@ -5014,6 +5012,205 @@ var readRegularFileNoFollow = async (target, options) => {
     await handle.close();
   }
 };
+async function* readRegularFileChunksNoFollow(target, options) {
+  const handle = await openRegularFileNoFollow(target, options.label);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || options.requireSingleLink && before.nlink !== 1)
+      throw invalidFileError(options.label);
+    if (options.requirePrivate && (before.mode & 63) !== 0)
+      throw new Error(`${options.label} permissions must not grant group or other access.`);
+    let offset = 0;
+    while (offset < before.size) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - offset));
+      const { bytesRead: bytesRead2 } = await handle.read(buffer, 0, buffer.length, offset);
+      if (!bytesRead2)
+        throw new FileChangedWhileReadingError(options.label);
+      offset += bytesRead2;
+      yield buffer.subarray(0, bytesRead2);
+    }
+    const probe = Buffer.allocUnsafe(1);
+    const { bytesRead } = await handle.read(probe, 0, 1, offset);
+    if (bytesRead || !sameOpenFile(before, await handle.stat()))
+      throw new FileChangedWhileReadingError(options.label);
+  } finally {
+    await handle.close();
+  }
+}
+
+// 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 createHash7, randomUUID as randomUUID2 } from "node:crypto";
+import path9 from "node:path";
+import { z as z6 } from "zod";
 
 // src/workspace/workspace-mutation-lock.ts
 import { createHash as createHash6 } from "node:crypto";
@@ -5277,6 +5474,7 @@ import { chmod as chmod4, link as link2, lstat as lstat10, open as open7, realpa
 import path14 from "node:path";
 import { z as z16 } from "zod";
 import { normalizeAgentRunState } from "@zhivex-ai/agents";
+import { createSqliteAgentRunStore as createSqliteAgentRunStore2 } from "@zhivex-ai/agents/ops";
 
 // src/runtime/runtime-policy.ts
 import { createBudgetGuard, createProductionSafetyPolicy } from "@zhivex-ai/agents";
@@ -10344,7 +10542,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     database.exec("PRAGMA foreign_keys = ON");
     await chmod3(databasePath, 384);
     const databaseLike = sqliteAdapter(database);
-    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
     const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
     const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
     return {
@@ -10496,7 +10694,12 @@ var canonicalJson2 = (value) => {
     return `[${value.map(canonicalJson2).join(",")}]`;
   return `{${Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson2(entry)}`).join(",")}}`;
 };
-var checksumPayload = (payload) => `sha256:${createHash13("sha256").update(canonicalJson2(payload)).digest("hex")}`;
+var checksumPayload = (payload) => {
+  const hash2 = createHash13("sha256");
+  for (const chunk of canonicalChunks(payload))
+    hash2.update(chunk);
+  return `sha256:${hash2.digest("hex")}`;
+};
 var stableKey2 = (kind, value) => createHash13("sha256").update(kind).update("\x00").update(value).digest("hex");
 var scopeValue2 = (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 ?? "*")}:`;
@@ -10528,8 +10731,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.");
     }
   }
@@ -10631,8 +10834,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 record2 = parseJsonRecord(row.state_json, `Run ${row.run_id}`);
+      const hydrated = record2.checkpointHistory ? (historyReader ??= createSqliteAgentRunStore2({ db: sqliteAdapter(database), history: "incremental" })).load(String(record2.runId), record2.scope) : record2;
+      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 }) => {
@@ -10792,7 +11000,19 @@ var writePrivateBackup = async (target, contents) => {
   try {
     handle = await open7(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 chmod4(staged, 384);
     await handle.close();
@@ -10819,12 +11039,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",
@@ -10834,19 +11055,14 @@ var exportHarnessStateBackup = async (config, target) => {
   };
 };
 var readHarnessStateBackup = async (source) => {
-  const { contents, stat: stat4 } = await readRegularFileNoFollow(path14.resolve(source), {
-    label: "Harness state backup",
-    maxBytes: HARNESS_STATE_BACKUP_MAX_BYTES,
-    requireSingleLink: true
-  });
-  if ((stat4.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(path14.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);
 };

package/dist/persistence/operations.d.ts

@@ -1,6 +1,8 @@
 import { type AgentRunState, type AgentStatus } from "@zhivex-ai/agents";
-import type { AgentMemoryStore, AgentRunStore } from "@zhivex-ai/agents/ops";
+import type { AgentMemoryStore, AgentRunStore, SqliteAgentRunStoreOptions } from "@zhivex-ai/agents/ops";
 import { type HarnessConfig, type HarnessStoreBackend } from "../runtime/config.js";
+import { SqliteDatabase } from "./sqlite-database.js";
+type SqliteDatabaseLike = SqliteAgentRunStoreOptions["db"];
 export declare const HARNESS_SQLITE_FILE = "operations.sqlite";
 export declare const HARNESS_OPERATIONS_SCHEMA_VERSION: 1;
 export declare const TERMINAL_RUN_STATUSES: readonly ["completed", "failed", "cancelled", "timed_out"];
@@ -313,7 +315,9 @@ export declare const cleanupHarnessRuns: (store: AgentRunStore, config: HarnessC
     statuses: AgentStatus[];
     deleted: number;
 }>;
+export declare const sqliteAdapter: (database: SqliteDatabase) => SqliteDatabaseLike;
 export declare const migrateLegacyFileRuns: (directory: string, target: AgentRunStore, config: HarnessConfig) => Promise<HarnessMigrationResult>;
 export declare const openHarnessPersistence: (config: HarnessConfig, options?: {
     migrateLegacyFileStore?: boolean;
 }) => Promise<HarnessPersistence>;
+export {};

package/dist/persistence/state-backup-stream.d.ts

@@ -0,0 +1,4 @@
+/** Canonical JSON without allocating a serialized copy of the entire bundle. */
+export declare function canonicalChunks(value: unknown): Generator<string>;
+export declare function segmentedChunks(value: unknown): Generator<string>;
+export declare function readBackupTransport(source: string, legacyMaxBytes: number): Promise<unknown>;

package/dist/service-cli.js

@@ -4579,6 +4579,31 @@ var readRegularFileNoFollow = async (target, options) => {
     await handle.close();
   }
 };
+async function* readRegularFileChunksNoFollow(target, options) {
+  const handle = await openRegularFileNoFollow(target, options.label);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || options.requireSingleLink && before.nlink !== 1)
+      throw invalidFileError(options.label);
+    if (options.requirePrivate && (before.mode & 63) !== 0)
+      throw new Error(`${options.label} permissions must not grant group or other access.`);
+    let offset = 0;
+    while (offset < before.size) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - offset));
+      const { bytesRead: bytesRead2 } = await handle.read(buffer, 0, buffer.length, offset);
+      if (!bytesRead2)
+        throw new FileChangedWhileReadingError(options.label);
+      offset += bytesRead2;
+      yield buffer.subarray(0, bytesRead2);
+    }
+    const probe = Buffer.allocUnsafe(1);
+    const { bytesRead } = await handle.read(probe, 0, 1, offset);
+    if (bytesRead || !sameOpenFile(before, await handle.stat()))
+      throw new FileChangedWhileReadingError(options.label);
+  } finally {
+    await handle.close();
+  }
+}
 
 // src/workspace/workspace-mutation-lock.ts
 init_errors();
@@ -10587,7 +10612,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     database.exec("PRAGMA foreign_keys = ON");
     await chmod3(databasePath, 384);
     const databaseLike = sqliteAdapter(database);
-    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
     const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
     const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
     return {

package/dist/{service-client-cli-50sympxb.js → service-client-cli-yx56n0hc.js}

@@ -11,7 +11,7 @@ import {
   navigateConsole,
   sanitizeTerminalText,
   serializeStreamResult
-} from "./cli-entry-b0dtz99m.js";
+} from "./cli-entry-c2f58zj2.js";
 import {
   HARNESS_VERSION
 } from "./cli-entry-64pdp3k5.js";

package/dist/verify-historical-migrations.js

@@ -8163,7 +8163,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     database.exec("PRAGMA foreign_keys = ON");
     await chmod3(databasePath, 384);
     const databaseLike = sqliteAdapter(database);
-    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
+    const store = withBudgetLedgerStore(createSqliteAgentRunStore({ db: databaseLike, scope: config.scope, history: "incremental" }), createSqliteAgentRunStore({ db: databaseLike, scope: budgetScopeFor(config) }), config);
     const memory = createSqliteAgentMemoryStore({ db: databaseLike, scope: config.scope });
     const migration = shouldMigrateLegacyRuns(config, options.migrateLegacyFileStore) ? await migrateLegacyFileRuns(config.stateDirectory, store, config) : emptyMigration();
     return {
@@ -8180,6 +8180,45 @@ var openHarnessPersistence = async (config, options = {}) => {
   }
 };
 
+// src/persistence/state-backup-stream.ts
+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 "}";
+  }
+}
+
 // src/persistence/workspace-checkpoints.ts
 import { createHash as createHash11, randomUUID as randomUUID6 } from "node:crypto";
 import { z as z13 } from "zod";
@@ -8210,6 +8249,7 @@ import { chmod as chmod4, link as link2, lstat as lstat10, open as open7, realpa
 import path13 from "node:path";
 import { z as z14 } from "zod";
 import { normalizeAgentRunState } from "@zhivex-ai/agents";
+import { createSqliteAgentRunStore as createSqliteAgentRunStore2 } 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"]);
@@ -8336,14 +8376,12 @@ var stateBackupPayloadSchema = z14.object({
   }).strict()
 }).strict();
 var stateBackupBundleSchema = stateBackupPayloadSchema.extend({ checksum: digestSchema2 }).strict();
-var canonicalJson = (value) => {
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value);
-  if (Array.isArray(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) => {
+  const hash2 = createHash12("sha256");
+  for (const chunk of canonicalChunks(payload))
+    hash2.update(chunk);
+  return `sha256:${hash2.digest("hex")}`;
 };
-var checksumPayload = (payload) => `sha256:${createHash12("sha256").update(canonicalJson(payload)).digest("hex")}`;
 var stableKey2 = (kind, value) => createHash12("sha256").update(kind).update("\x00").update(value).digest("hex");
 var scopeValue2 = (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 ?? "*")}:`;
@@ -8478,8 +8516,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 record2 = parseJsonRecord(row.state_json, `Run ${row.run_id}`);
+      const hydrated = record2.checkpointHistory ? (historyReader ??= createSqliteAgentRunStore2({ db: sqliteAdapter(database), history: "incremental" })).load(String(record2.runId), record2.scope) : record2;
+      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 }) => {
@@ -10030,11 +10073,11 @@ var createEmptyHarnessContextBundle = () => {
     schemaVersion: HARNESS_CONTEXT_BUNDLE_SCHEMA_VERSION,
     scope: "project",
     ...identity,
-    fingerprint: digestBytes2(canonicalJson2(harnessContextFingerprintInput(identity)))
+    fingerprint: digestBytes2(canonicalJson(harnessContextFingerprintInput(identity)))
   };
 };
 var digestBytes2 = (value) => `sha256:${createHash16("sha256").update(value).digest("hex")}`;
-var canonicalJson2 = (value) => JSON.stringify(value);
+var canonicalJson = (value) => JSON.stringify(value);
 var validateRelativePath = (value) => {
   const parsed = workspaceFilePathSchema.safeParse(value);
   if (!parsed.success) {
@@ -10276,7 +10319,7 @@ var loadHarnessProjectContext = async (workspace, options = {}) => {
     sources,
     skills
   };
-  const fingerprint = digestBytes2(canonicalJson2(harnessContextFingerprintInput(identity)));
+  const fingerprint = digestBytes2(canonicalJson(harnessContextFingerprintInput(identity)));
   return {
     schemaVersion: HARNESS_CONTEXT_BUNDLE_SCHEMA_VERSION,
     scope: "project",
@@ -12649,16 +12692,16 @@ ${contextInstructions}` : ""}${enabledDelegations}`,
     }
   };
 };
-var canonicalJson3 = (value) => {
+var canonicalJson2 = (value) => {
   if (value === null || typeof value !== "object")
     return JSON.stringify(value);
   if (Array.isArray(value))
-    return `[${value.map(canonicalJson3).join(",")}]`;
+    return `[${value.map(canonicalJson2).join(",")}]`;
   const record4 = value;
-  return `{${Object.keys(record4).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson3(record4[key])}`).join(",")}}`;
+  return `{${Object.keys(record4).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(record4[key])}`).join(",")}}`;
 };
 var localApprovalResolutionPayload = (inputDigest, approve, reason) => JSON.stringify({ inputDigest, approve, reason: reason ?? null });
-var terminalToolCallId = (runId, step, providerToolCallId, toolName2, input) => `tool_${createHash22("sha256").update(`${runId}\x00${step}\x00${providerToolCallId}\x00${toolName2}\x00${canonicalJson3(input)}`).digest("hex")}`;
+var terminalToolCallId = (runId, step, providerToolCallId, toolName2, input) => `tool_${createHash22("sha256").update(`${runId}\x00${step}\x00${providerToolCallId}\x00${toolName2}\x00${canonicalJson2(input)}`).digest("hex")}`;
 var recoverableTerminalStaleDigest = (toolName2, message) => toolName2 === "verify_and_apply_reviewed_edits" && /^Stale patch rejected for .+\.$/.test(message);
 var patchIdMismatch = (error) => {
   for (let depth = 0;depth < 8 && error instanceof Error; depth++, error = error.cause) {
@@ -12736,7 +12779,7 @@ var executeTerminalReceiptToolOwned = async (harness, waiting, approval, respons
       definition.approvalVersion,
       `environment:${session.binding.fingerprint}`
     ].filter(Boolean).join("|") || "1";
-    const inputDigest = createHash22("sha256").update(canonicalJson3({
+    const inputDigest = createHash22("sha256").update(canonicalJson2({
       runId: waiting.state.runId,
       step: approval.step,
       toolCallId: approval.toolCallId,
@@ -12744,7 +12787,7 @@ var executeTerminalReceiptToolOwned = async (harness, waiting, approval, respons
       input: serializedInput,
       toolVersion
     })).digest("hex");
-    if (approval.id !== `approval_${inputDigest}` || approval.inputDigest !== inputDigest || approval.toolVersion !== toolVersion || approval.arguments !== canonicalJson3(serializedInput)) {
+    if (approval.id !== `approval_${inputDigest}` || approval.inputDigest !== inputDigest || approval.toolVersion !== toolVersion || approval.arguments !== canonicalJson2(serializedInput)) {
       await session.release?.({ status: "failed", error: { message: "Approval binding mismatch." } });
       throw new Error("The terminal tool approval is stale or does not match the current runtime binding.");
     }
@@ -12941,7 +12984,7 @@ var executeTerminalReceiptToolOwned = async (harness, waiting, approval, respons
       finishedAt: now,
       toolResults: [...step.toolResults, toolResult]
     } : step);
-    const outputText = canonicalJson3(output);
+    const outputText = canonicalJson2(output);
     const previousRevision = waiting.state.revision ?? 0;
     const state = {
       ...waiting.state,

package/dist/workspace/file-security.d.ts

@@ -27,3 +27,9 @@ export declare const statRegularFileNoFollow: (target: string, options: Pick<Rea
  * time-of-check/time-of-use windows.
  */
 export declare const readRegularFileNoFollow: (target: string, options: ReadRegularFileNoFollowOptions) => Promise<StableRegularFile>;
+/** Descriptor-bound bounded reads; identity is revalidated before successful EOF. */
+export declare function readRegularFileChunksNoFollow(target: string, options: {
+    label: string;
+    requireSingleLink?: boolean;
+    requirePrivate?: boolean;
+}): AsyncGenerator<Buffer>;

package/dist/zhx.js

@@ -18,6 +18,6 @@ if (argv.length === 1 && ["--version", "-v", "version"].includes(argv[0])) {
   process.stdout.write(`${shortCliHelp(HARNESS_VERSION)}
 `);
 } else {
-  const { runCli } = await import("./cli-3qwxrh91.js");
+  const { runCli } = await import("./cli-3jmy4h5h.js");
   await runCli(argv);
 }

package/docs/DURABLE_OPERATIONS.md

@@ -64,6 +64,14 @@ zhx sessions archive <sessionId>
 
 The store uses SQLite WAL transactions, optimistic revisions, workspace/scope hashes, owner-only permissions, soft deletion/retention, and bounded session/run/metadata/index sizes. It rejects a new run while the latest session run is active or waiting for approval. Fork and archive operations also require a terminal branch point.
 
+SQLite runs store steps, tool results and compaction records separately from the active checkpoint. Large repeated text is retained in per-run content-addressed artifacts. Checkpoint and history changes commit in the same transaction; unchanged historical records are not rewritten. The 4 MiB state limit applies to the active checkpoint, including current messages, approvals, metadata and counters. Conversation compaction still controls model input size independently.
+
+Loading a run reconstructs its complete state for compatibility with approvals, recovery and verification. Programmatic history inspection can use `store.loadHistory(runId, { field: "toolResults", offset: 0, limit: 50 }, scope)` to read a page. Full hydrated states and total disk usage can grow with the run; run retention remains necessary. File and in-memory stores retain the full-state size limit.
+
+Logical backups contain hydrated history rather than database references, so restoration does not require the original artifact tables. Exports up to 64 MiB retain the legacy JSON format; larger exports use the versioned `ZHIVEX-STATE-SEGMENTS-1` transport with bounded frames, including split strings. RC13 reads both formats and verifies the same logical checksum before import. Older versions cannot read segmented exports. File I/O and checksum serialization are incremental; the public backup/import APIs still hydrate the complete logical bundle in memory. Segmented files have no aggregate 64 MiB ceiling. A state-limit failure records a bounded terminal diagnostic on the last durable checkpoint; the unsaved payload is not claimed as preserved. Use `/status` to inspect the failed run before `/continue`. Recovery retains tool journal receipts and never re-executes an operation itself.
+
+Incremental SQLite history uses the published Core 1.26.0 and Agents 1.10.1 packages. No local dependency patch is required. Install this checkout with `bun install --frozen-lockfile`.
+
 ## Provider handoff safety
 
 Every console turn preallocates a new run ID and binds it permanently to one provider/model. Provider or model changes take effect only on the next run and are blocked while an approval is pending. Before transferring context to another provider/model, the console creates a bounded deterministic redacted summary: text is truncated and common credentials are removed, while tool inputs, outputs, and provider payloads are replaced by tool/type names.

package/docs/EXTENSIBILITY.md

@@ -8,7 +8,7 @@ Built-in registrations are Meta, Qwen, OpenAI, and Gemini. Each registration own
 
 Library callers can use `DEFAULT_PROVIDER_REGISTRY`, `BUILTIN_PROVIDER_REGISTRATIONS`, `createProviderRegistry`, or `DEFAULT_PROVIDER_REGISTRY.extend(...)`, then pass the registry to `resolveHarnessConfig`, `createProviderModel`, provider diagnostics, or `createHarness({ providerRegistry })`. Registration IDs, environment-variable names, defaults, diagnostics, and factories are validated before they become selectable.
 
-The coordinated stable SDK batch pins `@zhivex-ai/agents@1.10.0`, `@zhivex-ai/core@1.25.0`, `@zhivex-ai/meta@0.2.8`, `@zhivex-ai/qwen@0.16.2`, `@zhivex-ai/openai@0.13.6`, and `@zhivex-ai/gemini@0.12.3`. Qwen 0.16.2 types malformed Responses tool arguments and malformed SSE events; Core 1.25.0 satisfies its published dependency range. These exact versions are pinned in the lockfile. Stable SDK publication does not replace Harness release-bound certification. Qwen `0.11.x` normalizes missing, placeholder, and continuation tool-call identifiers inside the adapter; Harness retains its deterministic provider-boundary normalizer as defense in depth until the exact candidate passes the complete release-bound representative matrix. A Core override keeps one runtime contract identity across every adapter, while Core `1.13.0` corrects compaction usage accounting and interaction-group retention. OpenAI `0.11.2` preserves synthetic assistant history in Responses, so the harness no longer requires its compaction transport or accounting workarounds.
+The coordinated stable SDK batch pins `@zhivex-ai/agents@1.10.1`, `@zhivex-ai/core@1.26.0`, `@zhivex-ai/meta@0.2.8`, `@zhivex-ai/qwen@0.16.2`, `@zhivex-ai/openai@0.13.6`, and `@zhivex-ai/gemini@0.12.3`. Qwen 0.16.2 types malformed Responses tool arguments and malformed SSE events; Core 1.26.0 satisfies its published dependency range. These exact versions are pinned in the lockfile. Stable SDK publication does not replace Harness release-bound certification. Qwen `0.11.x` normalizes missing, placeholder, and continuation tool-call identifiers inside the adapter; Harness retains its deterministic provider-boundary normalizer as defense in depth until the exact candidate passes the complete release-bound representative matrix. A Core override keeps one runtime contract identity across every adapter, while Core `1.13.0` corrects compaction usage accounting and interaction-group retention. OpenAI `0.11.2` preserves synthetic assistant history in Responses, so the harness no longer requires its compaction transport or accounting workarounds.
 
 OpenAI is based on the GPT-5.6 family: `gpt-5.6-luna` is the default, with `gpt-5.6-terra` and `gpt-5.6-sol` available through `--model`. Availability remains organization-dependent while the upstream family is in limited preview, and the adapter uses the Responses API by default.
 

package/docs/FIRST_USE.md

@@ -1,13 +1,13 @@
 # First use
 
-This guide targets the unpublished `1.2.0-rc.12` candidate. Installation commands become available after protected publication to npm `next`; stable users can install `@zhivex-ai/harness@latest`.
+This guide targets the unpublished `1.2.0-rc.13` candidate. Installation commands become available after protected publication to npm `next`; stable users can install `@zhivex-ai/harness@latest`.
 
 ## Install and start
 
 Install Node.js 22.13.0 or newer and Git. Then:
 
 ```sh
-npm install -g @zhivex-ai/harness@1.2.0-rc.12
+npm install -g @zhivex-ai/harness@1.2.0-rc.13
 cd /path/to/your/project
 zhx
 ```
@@ -82,16 +82,16 @@ For command execution, configure [OCI isolation](EXECUTION_ENVIRONMENTS.md).
 With Bun 1.4.0 or newer and a supported Node runtime:
 
 ```sh
-bun add --global @zhivex-ai/harness@1.2.0-rc.12
+bun add --global @zhivex-ai/harness@1.2.0-rc.13
 zhx
 ```
 
 For a disposable version/help/environment check without a global installation:
 
 ```sh
-bunx @zhivex-ai/harness@1.2.0-rc.12 --version
-bunx @zhivex-ai/harness@1.2.0-rc.12 --help
-bunx @zhivex-ai/harness@1.2.0-rc.12 doctor
+bunx @zhivex-ai/harness@1.2.0-rc.13 --version
+bunx @zhivex-ai/harness@1.2.0-rc.13 --help
+bunx @zhivex-ai/harness@1.2.0-rc.13 doctor
 ```
 
 For source development, use the [contributor guide](https://github.com/Zhivex/zhivex-harness/blob/main/CONTRIBUTING.md).

package/evaluations/representative-assembly-matrix.json

@@ -43,7 +43,8 @@
     "v1.2.0-rc.9",
     "v1.2.0-rc.10",
     "v1.2.0-rc.11",
-    "v1.2.0-rc.12"
+    "v1.2.0-rc.12",
+    "v1.2.0-rc.13"
   ],
   "expectedModels": [
     {
@@ -381,6 +382,14 @@
         "qwen": "qwen3.8-flash",
         "openai": "gpt-6-luna"
       }
+    },
+    {
+      "releaseTag": "v1.2.0-rc.13",
+      "models": {
+        "meta": "muse-spark-1.3-contributor",
+        "qwen": "qwen3.8-flash",
+        "openai": "gpt-6-luna"
+      }
     }
   ],
   "expectedCases": [

package/examples/README.md

@@ -8,13 +8,13 @@ Requirements: Bun 1.4.0+, Node.js 22.13.0+, and Git on macOS or Linux. This inst
 harness_demo_dir=$(mktemp -d)
 cd "$harness_demo_dir"
 printf '{"name":"harness-first-run","private":true}\n' > package.json
-bun add --exact --ignore-scripts @zhivex-ai/harness@1.2.0-rc.12
+bun add --exact --ignore-scripts @zhivex-ai/harness@1.2.0-rc.13
 ./node_modules/.bin/zhx --version
 ./node_modules/.bin/zhx --help
 ./node_modules/.bin/zhx doctor --provider openai --json
 ```
 
-Version must print `1.2.0-rc.12`; help lists commands. Doctor does not contact a provider. Without `OPENAI_API_KEY`, it reports the missing credential and exits with code `3`; inspect the JSON checks before proceeding. A directory without Git initialization can also produce a diagnostic warning. No paid model call is required for these checks. Both `zhx` and `zhivex-harness` are installed aliases; Bun manages installation, and their shebang runs Node.
+Version must print `1.2.0-rc.13`; help lists commands. Doctor does not contact a provider. Without `OPENAI_API_KEY`, it reports the missing credential and exits with code `3`; inspect the JSON checks before proceeding. A directory without Git initialization can also produce a diagnostic warning. No paid model call is required for these checks. Both `zhx` and `zhivex-harness` are installed aliases; Bun manages installation, and their shebang runs Node.
 
 To continue in your actual project, use the [global installation and credential setup](../README.md#installation), then `zhx init --profile daily --provider openai` and `zhx doctor --profile daily`. Real tasks require the selected provider credential in the process environment. Profiles store provider/model choices, never credentials. See [CLI](../docs/CLI.md) and [support](../SUPPORT.md).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhivex-ai/harness",
-  "version": "1.2.0-rc.12",
+  "version": "1.2.0-rc.13",
   "description": "Governed, provider-portable runtime for coding agents with durable approvals and isolated repository execution.",
   "type": "module",
   "license": "MIT",
@@ -146,8 +146,8 @@
     "release:prepare": "bun run scripts/prepare-release.ts"
   },
   "dependencies": {
-    "@zhivex-ai/agents": "1.10.0",
-    "@zhivex-ai/core": "1.25.0",
+    "@zhivex-ai/agents": "1.10.1",
+    "@zhivex-ai/core": "1.26.0",
     "@zhivex-ai/gemini": "0.12.3",
     "@zhivex-ai/meta": "0.2.8",
     "@zhivex-ai/openai": "0.13.6",
@@ -155,7 +155,7 @@
     "zod": "4.6.5"
   },
   "overrides": {
-    "@zhivex-ai/core": "1.25.0"
+    "@zhivex-ai/core": "1.26.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/server": "2.0.0",