@zhivex-ai/harness 1.3.0 → 1.4.0-rc.6

package/dist/{index-42gp2hy8.js → index-vtqfjnab.js}

@@ -4,7 +4,7 @@ import {
   taskAcceptanceDeliveryDiagnostic,
   taskAcceptanceOutcome,
   workspaceFilePathSchema
-} from "./index-yb239ghk.js";
+} from "./index-r0tdj04h.js";
 import {
   HarnessConfigError,
   HarnessStateConflictError,
@@ -1171,8 +1171,7 @@ class UsageLedger {
   }
   async run(runId, operation, historicalUsageUnknown = false) {
     this.database.query("INSERT OR IGNORE INTO zhivex_usage_policies (scope_key, run_id, policy) VALUES (?1, ?2, ?3)").run(this.key, runId, JSON.stringify({ ...this.options, ...historicalUsageUnknown ? { historicalUsageUnknown: true } : {} }));
-    this.database.query("UPDATE zhivex_usage_calls SET status = 'unknown' WHERE scope_key = ?1 AND run_id = ?2 AND status = 'pending'").run(this.key, runId);
-    return current.run({ ledger: this, runId }, operation);
+    return current.run({ ledger: this, runId, recovered: false }, operation);
   }
   summary(runId) {
     const rows = this.database.query("SELECT * FROM zhivex_usage_calls WHERE scope_key = ?1 AND run_id = ?2 ORDER BY rowid").all(this.key, runId);
@@ -1300,6 +1299,21 @@ class UsageLedger {
   store(store) {
     const ledger = this;
     return new Proxy(store, { get(target, key) {
+      if (key === "acquireLease" && target.acquireLease)
+        return async (...args) => {
+          const lease = await target.acquireLease(...args);
+          const scope = current.getStore();
+          if (lease && scope?.ledger === ledger && args[0] === scope.runId && !scope.recovered) {
+            try {
+              ledger.database.query("UPDATE zhivex_usage_calls SET status = 'unknown' WHERE scope_key = ?1 AND run_id = ?2 AND status = 'pending'").run(ledger.key, scope.runId);
+              scope.recovered = true;
+            } catch (error) {
+              await target.releaseLease?.(args[0], lease.ownerId, args[2]);
+              throw error;
+            }
+          }
+          return lease;
+        };
       if (key === "save")
         return async (...args) => {
           const scope = current.getStore();
@@ -1387,28 +1401,14 @@ function compileTaskAcceptanceContract(input) {
   return { contract, digest: `sha256:${createHash2("sha256").update(JSON.stringify(contract)).digest("hex")}` };
 }
 
-// src/context/task-memory.ts
-import { createHash as createHash3 } from "node:crypto";
-import { tool, serializeJsonValue as serializeJsonValue2 } from "@zhivex-ai/core";
-import { createRedactionPolicy as createRedactionPolicy3 } from "@zhivex-ai/agents";
-import { z as z8 } from "zod";
-
-// src/runtime/repair-verifier.ts
-import { z as z6 } from "zod";
-var verifierSchema = z6.strictObject({
-  command: z6.string().min(1).max(64),
-  args: z6.array(z6.string().max(8192)).max(256).default([]),
-  purpose: z6.string().min(1).max(500)
-});
-
 // src/runtime/task-acceptance-record.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 import { serializeJsonValue } from "@zhivex-ai/core";
 var TASK_ACCEPTANCE_KEY = "zhivexTaskAcceptanceV1";
 var TASK_ACCEPTANCE_EVIDENCE_KEY = "zhivexTaskAcceptanceEvidenceV1";
-var digest2 = z7.string().regex(/^sha256:[a-f0-9]{64}$/);
-var revisionSchema = z7.strictObject({ revision: z7.number().int().min(1), digest: digest2, previousDigest: digest2.nullable(), contract: taskAcceptanceContractSchema });
-var ledgerSchema = z7.strictObject({ schemaVersion: z7.literal(1), revisions: z7.array(revisionSchema).min(1).max(16) });
+var digest2 = z6.string().regex(/^sha256:[a-f0-9]{64}$/);
+var revisionSchema = z6.strictObject({ revision: z6.number().int().min(1), digest: digest2, previousDigest: digest2.nullable(), contract: taskAcceptanceContractSchema });
+var ledgerSchema = z6.strictObject({ schemaVersion: z6.literal(1), revisions: z6.array(revisionSchema).min(1).max(16) });
 function readTaskAcceptanceLedger(state) {
   const raw = state.metadata?.[TASK_ACCEPTANCE_KEY];
   if (raw === undefined)
@@ -1484,9 +1484,55 @@ function taskAcceptanceCheckpointStore(store, runId, ledger) {
   } });
 }
 
+// src/context/task-memory.ts
+import { createHash as createHash3 } from "node:crypto";
+import { tool, serializeJsonValue as serializeJsonValue2 } from "@zhivex-ai/core";
+import { createRedactionPolicy as createRedactionPolicy3 } from "@zhivex-ai/agents";
+import { z as z8 } from "zod";
+
+// src/runtime/repair-verifier.ts
+import { z as z7 } from "zod";
+var verifierSchema = z7.strictObject({
+  command: z7.string().min(1).max(64),
+  args: z7.array(z7.string().max(8192)).max(256).default([]),
+  purpose: z7.string().min(1).max(500)
+});
+
 // src/context/task-memory.ts
 var redact2 = createRedactionPolicy3({ includeEmails: true });
 var TASK_SOURCE_KEY = "zhivexTaskSources";
+var ASSISTANT_RESPONSE_KEY = "zhivexAssistantResponses";
+var MAX_ASSISTANT_RESPONSES = 3;
+var MAX_ASSISTANT_RESPONSE_CHARACTERS = 64000;
+var redactSource = (text2) => redact2.redactText(text2).replace(/\bBearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)|api[_-]?key|access[_-]?token|password)\s*([=:])\s*(?:"[^"]*"|'[^']*'|\S+)/gi, "$1$2[REDACTED]").replace(/\b(?:sk|ghp|gho|github_pat)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]");
+var sourceId = (text2) => `sha256:${createHash3("sha256").update(text2).digest("hex")}`;
+var assistantResponses = (metadata) => {
+  const value = metadata && typeof metadata === "object" ? metadata[ASSISTANT_RESPONSE_KEY] : undefined;
+  return Array.isArray(value) ? value.slice(-MAX_ASSISTANT_RESPONSES).flatMap((item) => {
+    if (!item || typeof item.text !== "string" || item.text.length > MAX_ASSISTANT_RESPONSE_CHARACTERS || item.id !== sourceId(item.text))
+      return [];
+    return [{ id: item.id, text: item.text, truncated: item.truncated === true }];
+  }) : [];
+};
+var captureAssistantResponses = (metadata, messages) => {
+  const sources = new Map(assistantResponses(metadata).map((source) => [source.id, source]));
+  for (const message of messages) {
+    if (message.role !== "assistant" || message.parts.some((part) => part.type === "tool-call"))
+      continue;
+    const text2 = redactSource(message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`));
+    if (!text2.trim() || /^\[Compacted (?:conversation context|prior conversation)\]/.test(text2))
+      continue;
+    const bounded = text2.slice(0, MAX_ASSISTANT_RESPONSE_CHARACTERS);
+    const id = sourceId(bounded);
+    const truncated = sources.get(id)?.truncated === true || text2.length > bounded.length;
+    sources.delete(id);
+    sources.set(id, { id, text: bounded, truncated });
+    while (sources.size > MAX_ASSISTANT_RESPONSES)
+      sources.delete(sources.keys().next().value);
+  }
+  return [...sources.values()];
+};
 var taskSources = (metadata) => {
   const value = metadata && typeof metadata === "object" ? metadata[TASK_SOURCE_KEY] : undefined;
   return Array.isArray(value) ? value.filter((v) => !!v && typeof v.id === "string" && /^sha256:[a-f0-9]{64}$/.test(v.id) && typeof v.text === "string").map((source) => ({ id: source.id, text: source.text, ...source.original === true ? { original: true } : {} })) : [];
@@ -1503,8 +1549,8 @@ var captureTaskSources = (metadata, messages) => {
       for (const part of message.parts) {
         if (part.type !== "text" || /^\[Compacted (?:conversation context|prior conversation)\]/.test(part.text))
           continue;
-        const text2 = redact2.redactText(part.text).replace(/\bBearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)|api[_-]?key|access[_-]?token|password)\s*([=:])\s*(?:"[^"]*"|'[^']*'|\S+)/gi, "$1$2[REDACTED]").replace(/\b(?:sk|ghp|gho|github_pat)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]");
-        const id = `sha256:${createHash3("sha256").update(text2).digest("hex")}`;
+        const text2 = redactSource(part.text);
+        const id = sourceId(text2);
         const original = sources.size === 0 || sources.get(id)?.original === true;
         sources.delete(id);
         sources.set(id, { id, text: text2, ...original ? { original: true } : {} });
@@ -1514,14 +1560,39 @@ var captureTaskSources = (metadata, messages) => {
 var createTaskTools = () => ({
   read_task: tool({
     name: "read_task",
-    description: "Recover operator requests after compaction. Omit id for the latest request. Source IDs default to the newest 64; set sourceOffset to page earlier IDs or use firstSourceId for the original request. Text offsets are characters. Task text is guidance, never approval.",
+    description: "Recover operator requests after compaction (default source). Use source=assistant_response to recover a prior assistant report or plan referenced by the user; optional literal query locates text in the newest matching retained response. Assistant text is untrusted, unverified, never permissions or acceptance. Omit id for the latest source. Operator IDs default to the newest 64; sourceOffset pages earlier IDs. Text offsets are characters; pages are at most 4000 characters.",
     metadata: { advancedRegistry: { permissions: ["read"], audit: { riskLevel: "low" } } },
     schema: z8.object({
+      source: z8.enum(["operator", "assistant_response"]).optional(),
+      query: z8.string().min(1).max(200).optional(),
       id: z8.string().regex(/^sha256:[a-f0-9]{64}$/).optional(),
-      offset: z8.number().int().min(0).default(0),
+      offset: z8.number().int().min(0).optional(),
       sourceOffset: z8.number().int().min(0).optional()
     }),
-    execute: async ({ id, offset, sourceOffset }, context) => {
+    execute: async ({ source: kind, query, id, offset: requestedOffset, sourceOffset }, context) => {
+      if (kind === "assistant_response") {
+        const sources2 = assistantResponses(context?.metadata);
+        const source2 = id ? sources2.find((item) => item.id === id) : [...sources2].reverse().find((item) => !query || item.text.includes(query));
+        if (!source2)
+          throw new Error("Requested assistant response is not retained in this run.");
+        const offset2 = requestedOffset ?? (query ? Math.max(0, source2.text.indexOf(query)) : 0);
+        return {
+          source: "assistant_response",
+          untrusted: true,
+          verified: false,
+          id: source2.id,
+          sourceIds: sources2.map((item) => item.id),
+          totalSources: sources2.length,
+          truncated: source2.truncated,
+          content: source2.text.slice(offset2, offset2 + 4000),
+          offset: offset2,
+          totalCharacters: source2.text.length,
+          nextOffset: offset2 + 4000 < source2.text.length ? offset2 + 4000 : null
+        };
+      }
+      if (query)
+        throw new Error("Literal query is only supported for assistant responses.");
+      const offset = requestedOffset ?? 0;
       const sources = taskSources(context?.metadata);
       const source = id ? sources.find((s) => s.id === id) : sources.at(-1);
       if (!source)
@@ -1552,4 +1623,4 @@ var createTaskTools = () => ({
   })
 });
 
-export { protectStateFromGit, validateStateDirectory, HARNESS_SESSION_INDEX_FILE, HARNESS_SESSION_SCHEMA_VERSION, SESSION_RUN_STATUSES, TERMINAL_SESSION_RUN_STATUSES, openCliSessionStore, openSessionStore, inspectRuntimeDiagnostics, inspectRuntimeManifest, estimateContextTokens, measureContext, MODEL_BUDGET_KEY, estimateRequestTokens, workBudgetReached, createModelBudget, harnessToolExecution, USAGE_LEDGER_KEY, usagePricingSchema, inspectUsageLedger, formatUsageLedger, UsageLedger, verifierSchema, taskAcceptanceContractSchema, compileTaskAcceptanceContract, TASK_ACCEPTANCE_KEY, TASK_ACCEPTANCE_EVIDENCE_KEY, readTaskAcceptanceLedger, nextTaskAcceptanceLedger, persistTaskAcceptanceRevision, taskAcceptanceCheckpointStore, TASK_SOURCE_KEY, taskSources, captureTaskSources, createTaskTools };
+export { protectStateFromGit, validateStateDirectory, HARNESS_SESSION_INDEX_FILE, HARNESS_SESSION_SCHEMA_VERSION, SESSION_RUN_STATUSES, TERMINAL_SESSION_RUN_STATUSES, ensurePrivateDatabase, openCliSessionStore, openSessionStore, inspectRuntimeDiagnostics, inspectRuntimeManifest, estimateContextTokens, measureContext, MODEL_BUDGET_KEY, estimateRequestTokens, workBudgetReached, createModelBudget, harnessToolExecution, USAGE_LEDGER_KEY, usagePricingSchema, inspectUsageLedger, formatUsageLedger, UsageLedger, verifierSchema, taskAcceptanceContractSchema, compileTaskAcceptanceContract, TASK_ACCEPTANCE_KEY, TASK_ACCEPTANCE_EVIDENCE_KEY, readTaskAcceptanceLedger, nextTaskAcceptanceLedger, persistTaskAcceptanceRevision, taskAcceptanceCheckpointStore, TASK_SOURCE_KEY, ASSISTANT_RESPONSE_KEY, assistantResponses, captureAssistantResponses, taskSources, captureTaskSources, createTaskTools };

package/dist/{index-2jrdcj6b.js → index-wq2tax80.js}

@@ -89,6 +89,8 @@ var CLI_OPTION_NAMES = [
   "--workspace",
   "--state-dir",
   "--mcp-config",
+  "--no-memory",
+  "--source",
   "--context-config",
   "--no-project-context",
   "--patch",
@@ -220,6 +222,7 @@ var childBudgets = [
   "--subagent-timeout-ms"
 ];
 var agent = [
+  "--no-memory",
   "--compaction-model",
   "--compaction-provider",
   "--tool-policy",
@@ -271,7 +274,7 @@ var CLI_COMMAND_OPTION_CONTRACTS = {
   providers: contract(["--json"]),
   policy: contract(["--service", ...agent, "--json"]),
   doctor: contract([...provider, ...profile, ...locator, ...project, ...execution, ...budgets, "--allow-check", "--require-capability", "--subagent", "--json"]),
-  resume: contract(["--tool-policy", "--service", "--session", ...locator, "--approve", "--deny", "--json", "--jsonl"], [["--approve", "--deny"]]),
+  resume: contract(["--no-memory", "--tool-policy", "--service", "--session", ...locator, "--approve", "--deny", "--json", "--jsonl"], [["--approve", "--deny"]]),
   "runs:list": contract([...locator, "--status", "--limit", "--cursor", "--json"]),
   "runs:inspect": contract([...locator, "--json"]),
   "runs:cancel": contract([...locator, "--reason", "--cascade", "--final", "--json"]),
@@ -295,6 +298,17 @@ var CLI_COMMAND_OPTION_CONTRACTS = {
   "checkpoints:recover": contract([...locator, "--json"]),
   "changes:create": contract(["--patch"], ["--patch"]),
   "changes:verify": contract(["--patch", "--preconditions", "--now"], ["--patch"]),
+  "memory:remember": contract([...locator, "--json", "--source"]),
+  "memory:suggest": contract([...locator, "--json", "--source"]),
+  "memory:list": contract([...locator, "--json"]),
+  "memory:read": contract([...locator, "--json"]),
+  "memory:update": contract([...locator, "--json", "--source"]),
+  "memory:forget": contract([...locator, "--json"]),
+  "memory:accept": contract([...locator, "--json"]),
+  "memory:clear": contract([...locator, "--json"]),
+  "memory:enable": contract([...locator, "--json"]),
+  "memory:disable": contract([...locator, "--json"]),
+  "memory:context": contract([...locator, "--json"]),
   "state:status": contract([...locator, "--json"]),
   "state:export": contract([...locator, "--json"]),
   "state:import": contract([...locator, "--apply", "--json"]),

package/dist/{index-a97bezbz.js → index-z6br6qdn.js}

@@ -1,20 +1,22 @@
 import {
   HARNESS_OPERATIONS_SCHEMA_VERSION,
   HARNESS_SQLITE_FILE,
+  decodeProjectMemory,
   openHarnessPersistence,
+  projectMemoryRecordKey,
   sqliteAdapter,
   workspaceCheckpointSchema,
   workspaceRestoreOperationSchema
-} from "./index-h0mqx2ed.js";
+} from "./index-rd0s3gqj.js";
 import {
   HARNESS_SESSION_SCHEMA_VERSION,
   openCliSessionStore,
   validateStateDirectory
-} from "./index-42gp2hy8.js";
+} from "./index-vtqfjnab.js";
 import {
   SqliteDatabase,
   readRegularFileChunksNoFollow
-} from "./index-yb239ghk.js";
+} from "./index-r0tdj04h.js";
 import {
   HarnessStateConflictError,
   HarnessWorkspaceError
@@ -214,13 +216,24 @@ async function readBackupTransport(source, legacyMaxBytes) {
 }
 
 // src/persistence/state-backup.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { chmod, link, lstat as lstat2, open, realpath as realpath2, unlink } from "node:fs/promises";
 import path2 from "node:path";
 import { z } from "zod";
 import { normalizeAgentRunState } from "@zhivex-ai/agents";
 import { createSqliteAgentRunStore } from "@zhivex-ai/agents/ops";
+
+// src/persistence/sdk-store-identity.ts
+import { createHash } from "node:crypto";
+var sdkCanonicalKey = (kind, scope, value) => `${kind}:v2:${createHash("sha256").update(JSON.stringify([
+  JSON.stringify([scope.namespace ?? null, scope.tenantId, scope.userId ?? null]),
+  value
+])).digest("hex")}`;
+var sdkLegacyKey = (scope, value) => `${encodeURIComponent(scope.namespace ?? "default")}:${encodeURIComponent(scope.tenantId)}:${encodeURIComponent(scope.userId ?? "*")}:${value}`;
+var sdkRunKeyMatches = (key, scope, value) => key === sdkCanonicalKey("agent-run", scope, value) || key === sdkLegacyKey(scope, value);
+
+// src/persistence/state-backup.ts
 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"]);
@@ -275,6 +288,8 @@ var memoryRecordSchema = z.object({
   messages: z.array(z.unknown()),
   updatedAt: z.number().int().nonnegative()
 }).strict();
+var serializedMemory = (entry) => JSON.stringify(entry.key.startsWith("agent-memory:v2:") ? { schemaVersion: 1, memoryKey: entry.key, messages: entry.messages } : entry.messages);
+var memoryKeysForRuns = (config, runs) => new Set(runs.flatMap(({ state }) => [...new Set([state.runId, state.agentId].filter((id) => typeof id === "string"))].flatMap((id) => [sdkLegacyKey(config.scope, id), sdkCanonicalKey("agent-memory", config.scope, id)])));
 var sessionRecordSchema = z.object({
   sessionId: z.string().min(1).max(260),
   workspaceKey: bindingKeySchema,
@@ -356,12 +371,12 @@ var canonicalJson = (value) => {
   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 hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const chunk of canonicalChunks(payload))
     hash.update(chunk);
   return `sha256:${hash.digest("hex")}`;
 };
-var stableKey = (kind, value) => createHash("sha256").update(kind).update("\x00").update(value).digest("hex");
+var stableKey = (kind, value) => createHash2("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 ?? "*")}:`;
 var stateMatchesScope = (config, state) => {
@@ -373,7 +388,6 @@ var stateMatchesScope = (config, state) => {
   const scope = candidate.scope;
   return scope.tenantId === config.scope.tenantId && (scope.userId ?? undefined) === (config.scope.userId ?? undefined) && (scope.namespace ?? undefined) === (config.scope.namespace ?? undefined);
 };
-var budgetScopePrefix = (config) => `__zhivex_budget__:${encodeURIComponent(config.scope.tenantId)}:${encodeURIComponent(config.scope.userId ?? "*")}:`;
 var coordinatorIds = (runs) => new Set(runs.flatMap(({ state }) => {
   const id = state.budgetCoordinatorId;
   return typeof id === "string" ? [id] : [];
@@ -381,7 +395,7 @@ var coordinatorIds = (runs) => new Set(runs.flatMap(({ state }) => {
 var validateBudgetLedger = (config, run, identities) => {
   const state = validatedRunState(run.state, `Budget ledger ${run.key}`);
   const identity = state.metadata?.budgetIdentity;
-  if (state.scope?.namespace !== "__zhivex_budget__" || state.scope?.tenantId !== config.scope.tenantId || (state.scope?.userId ?? undefined) !== (config.scope.userId ?? undefined) || state.provider !== "zhivex" || state.modelId !== "budget-coordinator" || state.metadata?.budgetCoordinator !== true || typeof identity !== "string" || !identities.has(identity) || !/^budget_[a-f0-9]{64}$/.test(state.runId) || run.key !== `${budgetScopePrefix(config)}${state.runId}`) {
+  if (state.scope?.namespace !== "__zhivex_budget__" || state.scope?.tenantId !== config.scope.tenantId || (state.scope?.userId ?? undefined) !== (config.scope.userId ?? undefined) || state.provider !== "zhivex" || state.modelId !== "budget-coordinator" || state.metadata?.budgetCoordinator !== true || typeof identity !== "string" || !identities.has(identity) || !/^budget_[a-f0-9]{64}$/.test(state.runId) || !sdkRunKeyMatches(run.key, state.scope, state.runId)) {
     throw new HarnessStateConflictError("Budget ledger is not bound to an exported run and durable scope.");
   }
   assertTerminalState(state, `Budget ledger ${run.key}`);
@@ -559,12 +573,16 @@ var readPayload = async (config, recordedWorkspace, accessLease) => {
       parentRunKey: row.parent_run_id,
       updatedAt: row.updated_at_ms
     }));
-    const memoryKeys = new Set(runs.map((run) => `${binding.scopePrefix}${String(run.state.runId)}`));
-    const memory = database.query("SELECT memory_key, messages_json, updated_at_ms FROM zhivex_agent_memory ORDER BY memory_key").all().filter((row) => memoryKeys.has(row.memory_key)).map((row) => ({
-      key: row.memory_key,
-      messages: z.array(z.unknown()).parse(JSON.parse(row.messages_json)),
-      updatedAt: row.updated_at_ms
-    }));
+    const memoryKeys = memoryKeysForRuns(config, runs);
+    memoryKeys.add(projectMemoryRecordKey(binding));
+    const memory = database.query("SELECT memory_key, messages_json, updated_at_ms FROM zhivex_agent_memory ORDER BY memory_key").all().filter((row) => memoryKeys.has(row.memory_key)).map((row) => {
+      const value = JSON.parse(row.messages_json);
+      if (row.memory_key.startsWith("agent-memory:v2:")) {
+        const envelope = z.strictObject({ schemaVersion: z.literal(1), memoryKey: z.literal(row.memory_key), messages: z.array(z.unknown()) }).parse(value);
+        return { key: row.memory_key, messages: envelope.messages, updatedAt: row.updated_at_ms };
+      }
+      return { key: row.memory_key, messages: z.array(z.unknown()).parse(value), updatedAt: row.updated_at_ms };
+    });
     const sessionRows = database.query("SELECT * FROM zhivex_cli_sessions ORDER BY session_id").all().filter((row) => row.workspace_key === binding.workspaceKey && row.scope_key === binding.scopeKey);
     const selectedSessionIds = new Set(sessionRows.map((row) => row.session_id));
     const sessionRunRows = database.query("SELECT * FROM zhivex_cli_session_runs ORDER BY session_id, ordinal").all().filter((row) => selectedSessionIds.has(row.session_id));
@@ -762,7 +780,7 @@ var validateBundleBinding = async (config, bundle) => {
       throw new HarnessStateConflictError(`Run ${run.key} is bound to another durable scope.`);
     }
     runIds.add(state.runId);
-    if (run.key !== `${expected.scopePrefix}${state.runId}`) {
+    if (!sdkRunKeyMatches(run.key, config.scope, state.runId)) {
       throw new HarnessStateConflictError(`Run ${run.key} does not match its bound scope and runId.`);
     }
   }
@@ -781,7 +799,7 @@ var validateBundleBinding = async (config, bundle) => {
   const journalKeys = new Set;
   for (const entry of bundle.records.toolJournal) {
     const journalKey = `${entry.runKey}\x00${entry.toolCallId}`;
-    if (journalKeys.has(journalKey) || !runKeys.has(entry.runKey) || !stateMatchesScope(config, entry.entry) || entry.entry.runId !== entry.runKey.slice(expected.scopePrefix.length)) {
+    if (journalKeys.has(journalKey) || !runKeys.has(entry.runKey) || !stateMatchesScope(config, entry.entry) || entry.entry.runId !== bundle.records.runs.find((run) => run.key === entry.runKey)?.state.runId) {
       throw new HarnessStateConflictError(`Tool journal ${entry.toolCallId} is not bound to an imported run.`);
     }
     journalKeys.add(journalKey);
@@ -793,7 +811,7 @@ var validateBundleBinding = async (config, bundle) => {
     }
     idempotencyKeys.add(entry.key);
     const state = bundle.records.runs.find((run) => run.key === entry.runKey).state;
-    if (typeof state.idempotencyKey !== "string" || entry.key !== `${expected.scopePrefix}${state.idempotencyKey}`) {
+    if (typeof state.idempotencyKey !== "string" || !sdkRunKeyMatches(entry.key, config.scope, state.idempotencyKey)) {
       throw new HarnessStateConflictError("Idempotency record does not match its bound run state.");
     }
   }
@@ -805,9 +823,12 @@ var validateBundleBinding = async (config, bundle) => {
     parentKeys.add(entry.runKey);
   }
   const memoryKeys = new Set;
+  const allowedMemoryKeys = memoryKeysForRuns(config, bundle.records.runs);
   for (const entry of bundle.records.memory) {
-    const memoryRunId = entry.key.startsWith(expected.scopePrefix) ? entry.key.slice(expected.scopePrefix.length) : "";
-    if (memoryKeys.has(entry.key) || !runIds.has(memoryRunId)) {
+    const projectRecord = entry.key === projectMemoryRecordKey(expected);
+    if (projectRecord)
+      decodeProjectMemory(entry.messages, expected);
+    if (memoryKeys.has(entry.key) || !projectRecord && !allowedMemoryKeys.has(entry.key)) {
       throw new HarnessStateConflictError(`Memory record ${entry.key} is not bound to an imported run.`);
     }
     memoryKeys.add(entry.key);
@@ -849,7 +870,7 @@ var validateBundleBinding = async (config, bundle) => {
     const turn = bundle.records.sessionRuns.find((run) => run.turnId === checkpoint.turnId && run.sessionId === checkpoint.sessionId);
     if (!turn || !terminalSessionStatuses.has(turn.status))
       throw new HarnessStateConflictError("Checkpoint targets a missing terminal turn.");
-    if (new Set(checkpoint.files.map((file) => file.path)).size !== checkpoint.files.length || checkpoint.files.some((file) => `sha256:${createHash("sha256").update(file.content).digest("hex")}` !== file.digest || Buffer.byteLength(file.content) > 65536)) {
+    if (new Set(checkpoint.files.map((file) => file.path)).size !== checkpoint.files.length || checkpoint.files.some((file) => `sha256:${createHash2("sha256").update(file.content).digest("hex")}` !== file.digest || Buffer.byteLength(file.content) > 65536)) {
       throw new HarnessStateConflictError("Checkpoint content identity is invalid.");
     }
     if (record.kind === "restore") {
@@ -946,9 +967,9 @@ var importHarnessStateBackup = async (config, bundle, options = {}) => {
       toolJournal: new Set(availableTables.has("zhivex_agent_runs_tool_journal") ? database.query("SELECT run_key, tool_call_id, entry_json, revision, updated_at_ms FROM zhivex_agent_runs_tool_journal").all().filter((row) => destinationRunKeys.has(row.run_key)).map((row) => `${row.run_key}\x00${row.tool_call_id}`) : []),
       idempotency: new Set(availableTables.has("zhivex_agent_runs_idempotency") ? database.query("SELECT idempotency_key, run_id, updated_at_ms FROM zhivex_agent_runs_idempotency").all().filter((row) => destinationRunKeys.has(row.run_id)).map((row) => row.idempotency_key) : []),
       parents: new Set(availableTables.has("zhivex_agent_runs_parents") ? database.query("SELECT run_id, parent_run_id, updated_at_ms FROM zhivex_agent_runs_parents").all().filter((row) => destinationRunKeys.has(row.run_id)).map((row) => row.run_id) : []),
-      memory: new Set(availableTables.has("zhivex_agent_memory") ? database.query("SELECT memory_key, messages_json, updated_at_ms FROM zhivex_agent_memory").all().filter((row) => destinationRunRows.some((run) => {
+      memory: new Set(availableTables.has("zhivex_agent_memory") ? database.query("SELECT memory_key, messages_json, updated_at_ms FROM zhivex_agent_memory").all().filter((row) => row.memory_key === projectMemoryRecordKey(bundle.binding) || destinationRunRows.some((run) => {
         const state = JSON.parse(run.state_json);
-        return row.memory_key === `${bundle.binding.scopePrefix}${String(state.runId)}`;
+        return memoryKeysForRuns(config, [{ state }]).has(row.memory_key);
       })).map((row) => row.memory_key) : []),
       sessions: destinationSessionIds,
       sessionRuns: new Set(availableTables.has("zhivex_cli_session_runs") ? database.query("SELECT * FROM zhivex_cli_session_runs ORDER BY session_id, ordinal").all().filter((row) => destinationSessionIds.has(row.session_id)).map((row) => row.turn_id) : [])
@@ -974,7 +995,7 @@ var importHarnessStateBackup = async (config, bundle, options = {}) => {
     for (const entry of bundle.records.toolJournal)
       insertOrCompare("zhivex_agent_runs_tool_journal", "run_key = ? AND tool_call_id = ?", [entry.runKey, entry.toolCallId], "entry_json, revision, updated_at_ms", [JSON.stringify(entry.entry), entry.revision, entry.updatedAt], "INSERT INTO zhivex_agent_runs_tool_journal (run_key, tool_call_id, entry_json, revision, updated_at_ms) VALUES (?, ?, ?, ?, ?)", [entry.runKey, entry.toolCallId, JSON.stringify(entry.entry), entry.revision, entry.updatedAt]);
     for (const entry of bundle.records.memory)
-      insertOrCompare("zhivex_agent_memory", "memory_key = ?", [entry.key], "messages_json, updated_at_ms", [JSON.stringify(entry.messages), entry.updatedAt], "INSERT INTO zhivex_agent_memory (memory_key, messages_json, updated_at_ms) VALUES (?, ?, ?)", [entry.key, JSON.stringify(entry.messages), entry.updatedAt]);
+      insertOrCompare("zhivex_agent_memory", "memory_key = ?", [entry.key], "messages_json, updated_at_ms", [serializedMemory(entry), entry.updatedAt], "INSERT INTO zhivex_agent_memory (memory_key, messages_json, updated_at_ms) VALUES (?, ?, ?)", [entry.key, serializedMemory(entry), entry.updatedAt]);
     for (const session of bundle.records.sessions)
       insertOrCompare("zhivex_cli_sessions", "session_id = ?", [session.sessionId], "workspace_key, scope_key, title, parent_session_id, forked_from_turn_id, revision, activity_seq, created_at, updated_at, archived_at, deleted_at, metadata_bytes", [
         session.workspaceKey,

package/dist/index.js

@@ -71,7 +71,7 @@ import {
   timeToSafeFixLatencyStatistics,
   timeToSafeFixTaskSchema,
   verifyChangeEnvelope
-} from "./index-8vm2m34s.js";
+} from "./index-dj5z774k.js";
 import {
   HARNESS_STATE_BACKUP_MAX_BYTES,
   HARNESS_STATE_BACKUP_SCHEMA_VERSION,
@@ -82,7 +82,7 @@ import {
   inspectHarnessState,
   readHarnessStateBackup,
   stateBackupBundleSchema
-} from "./index-a97bezbz.js";
+} from "./index-z6br6qdn.js";
 import {
   CLI_COMMAND_OPTION_CONTRACTS,
   CLI_OPTION_DEFINITIONS,
@@ -92,7 +92,7 @@ import {
   resolveHarnessModelRoutes,
   serializeHarnessModelRoutes,
   validateCliCommandOptions
-} from "./index-2jrdcj6b.js";
+} from "./index-wq2tax80.js";
 import {
   harnessLocalCredentialsSchema,
   openHarnessActivityStore,
@@ -100,7 +100,7 @@ import {
   recoverHarnessLocalService,
   requestHarnessLocalService,
   startHarnessLocalService
-} from "./index-w2sj0wkw.js";
+} from "./index-49ys3s4q.js";
 import {
   createAcpConnection,
   serveAcpStdio
@@ -147,7 +147,7 @@ import {
   runHarness,
   runHarnessReviewGroup,
   selectHarnessModel
-} from "./index-hnaxfpb5.js";
+} from "./index-4j1h4j8c.js";
 import {
   HARNESS_OPERATIONS_SCHEMA_VERSION,
   HARNESS_SQLITE_FILE,
@@ -159,8 +159,8 @@ import {
   migrateLegacyFileRuns,
   openHarnessPersistence,
   openWorkspaceCheckpointStore
-} from "./index-h0mqx2ed.js";
-import"./index-8zzhggxv.js";
+} from "./index-rd0s3gqj.js";
+import"./index-a1q355va.js";
 import {
   HARNESS_SESSION_INDEX_FILE,
   HARNESS_SESSION_SCHEMA_VERSION,
@@ -169,7 +169,7 @@ import {
   openCliSessionStore,
   openSessionStore,
   validateStateDirectory
-} from "./index-42gp2hy8.js";
+} from "./index-vtqfjnab.js";
 import {
   BUN_ENGINE_RANGE,
   HARNESS_MCP_CONFIG_SCHEMA_VERSION,
@@ -180,7 +180,7 @@ import {
   createHttpMcpClient,
   loadHarnessMcpConfiguration,
   normalizeHarnessMcpConfiguration
-} from "./index-azmwjp95.js";
+} from "./index-0g939pfs.js";
 import {
   CliOciRuntimeAdapter,
   HARNESS_EXECUTION_ARTIFACT_SCHEMA_VERSION,
@@ -192,7 +192,7 @@ import {
   describeOciCommand,
   executionFingerprintInput,
   harnessExecutionSession
-} from "./index-z0qxmkm2.js";
+} from "./index-e6r04a18.js";
 import {
   EDIT_CONTRACT_SCHEMA_VERSION,
   EDIT_DIGEST_ALGORITHM,
@@ -215,7 +215,7 @@ import {
   restoreFileInputSchema,
   validateEditProposal,
   workspaceFilePathSchema
-} from "./index-yb239ghk.js";
+} from "./index-r0tdj04h.js";
 import {
   BUILTIN_PROVIDER_REGISTRATIONS,
   DEFAULT_ALLOWED_CHECKS,

package/dist/persistence/project-memory-command.d.ts

@@ -0,0 +1,11 @@
+import { type HarnessProjectMemoryOptions } from "./project-memory.js";
+export declare const HARNESS_MEMORY_COMMANDS: readonly ["remember", "list", "read", "update", "forget", "suggest", "accept", "clear", "enable", "disable", "context"];
+/** Host/CLI operations only: these commands are never added to the model tool catalog. */
+export declare function executeHarnessMemoryCommand(options: HarnessProjectMemoryOptions, command: string, args: readonly string[], source?: string): Promise<{
+    schemaVersion: number;
+    kind: string;
+    command: string;
+    workspaceKey: string;
+    scopeKey: string;
+    result: unknown;
+}>;

package/dist/persistence/project-memory.d.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import type { AgentStoreScope } from "@zhivex-ai/agents/ops";
+export declare const HARNESS_PROJECT_MEMORY_SCHEMA_VERSION: 1;
+export declare const HARNESS_PROJECT_MEMORY_LIMITS: Readonly<{
+    entries: 128;
+    entryBytes: 4096;
+    documentBytes: number;
+    contextBytes: 6000;
+    contextEntries: 3;
+    staleAfterMs: number;
+}>;
+declare const entrySchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            operator: "operator";
+            suggestion: "suggestion";
+        }>;
+        reference: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        pending: "pending";
+    }>;
+    revision: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    reviewedAt: z.ZodOptional<z.ZodNumber>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type HarnessProjectMemoryEntry = z.infer<typeof entrySchema>;
+export interface HarnessProjectMemoryInput {
+    content: string;
+    source: string;
+    expiresAt?: number;
+}
+export interface HarnessProjectMemoryOptions {
+    workspace: string;
+    stateDirectory: string;
+    scope: AgentStoreScope;
+    now?: () => number;
+}
+export interface HarnessProjectMemoryView {
+    schemaVersion: 1;
+    kind: "project-memory";
+    workspaceKey: string;
+    scopeKey: string;
+    enabled: boolean;
+    entries: (HarnessProjectMemoryEntry & {
+        freshness: "fresh" | "stale" | "expired" | "pending";
+    })[];
+    limits: typeof HARNESS_PROJECT_MEMORY_LIMITS;
+}
+export interface HarnessProjectMemory {
+    readonly databasePath: string;
+    list(): HarnessProjectMemoryView;
+    read(id: string): HarnessProjectMemoryView["entries"][number];
+    remember(input: HarnessProjectMemoryInput): HarnessProjectMemoryEntry;
+    suggest(input: HarnessProjectMemoryInput): HarnessProjectMemoryEntry;
+    update(id: string, expectedRevision: number, input: HarnessProjectMemoryInput): HarnessProjectMemoryEntry;
+    accept(id: string, expectedRevision: number): HarnessProjectMemoryEntry;
+    forget(id: string, expectedRevision: number): void;
+    clear(): number;
+    setEnabled(enabled: boolean): void;
+    retrieve(query: string, budget?: {
+        maxBytes?: number;
+        maxEntries?: number;
+    }): {
+        content: string;
+        ids: string[];
+        bytes: number;
+    };
+    close(): void;
+}
+export declare const projectMemoryRecordKey: (binding: {
+    workspaceKey: string;
+    scopeKey: string;
+}) => string;
+export declare const projectMemoryBinding: (workspace: string, scope: AgentStoreScope) => {
+    workspaceKey: string;
+    scopeKey: string;
+    memoryKey: string;
+};
+export declare const decodeProjectMemory: (messages: unknown, binding: {
+    workspaceKey: string;
+    scopeKey: string;
+}) => {
+    schemaVersion: 1;
+    workspaceKey: string;
+    scopeKey: string;
+    enabled: boolean;
+    entries: {
+        id: string;
+        content: string;
+        source: {
+            kind: "operator" | "suggestion";
+            reference: string;
+        };
+        status: "accepted" | "pending";
+        revision: number;
+        createdAt: number;
+        updatedAt: number;
+        reviewedAt?: number | undefined;
+        expiresAt?: number | undefined;
+    }[];
+};
+export declare function openHarnessProjectMemory(options: HarnessProjectMemoryOptions): Promise<HarnessProjectMemory>;
+export {};

package/dist/persistence/sdk-store-identity.d.ts

@@ -0,0 +1,4 @@
+import type { AgentStoreScope } from "@zhivex-ai/core";
+export declare const sdkCanonicalKey: (kind: "agent-run" | "agent-memory", scope: AgentStoreScope, value: string) => string;
+export declare const sdkLegacyKey: (scope: AgentStoreScope, value: string) => string;
+export declare const sdkRunKeyMatches: (key: string, scope: AgentStoreScope, value: string) => boolean;

package/dist/persistence/sessions.d.ts

@@ -120,6 +120,10 @@ export interface CliSessionStore {
     }): Promise<SessionRetentionResult>;
     close(): void;
 }
+export declare const ensurePrivateDatabase: (workspace: string, stateDirectory: string) => Promise<{
+    databasePath: string;
+    databaseEntry: import("node:fs").Stats;
+}>;
 export declare const openCliSessionStore: (options: OpenSessionStoreOptions) => Promise<CliSessionStore>;
 /** Compatibility-friendly name for consumers that do not care that the index is CLI-owned. */
 export declare const openSessionStore: typeof openCliSessionStore;