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

package/dist/{cli-etsmtst3.js → cli-s1rs15vv.js}

@@ -51,6 +51,7 @@ import {
   createHarnessResumeMetadata,
   createHarnessRouteModels,
   credentialModel,
+  decodeProjectMemory,
   digestChangeEnvelopeArtifact,
   estimateMessages,
   fileDigestSchema,
@@ -80,12 +81,14 @@ import {
   openCliSessionStore,
   openHarnessActivityStore,
   openHarnessPersistence,
+  openHarnessProjectMemory,
   openWorkspaceCheckpointStore,
   orchestrationObserver,
   parseCliArgs,
   parseHarnessModelRoute,
   persistedCliOptions,
   printTerminalResult,
+  projectMemoryRecordKey,
   publishPendingPolicyDecision,
   readHarnessResumeConfig,
   readHarnessResumeRoutes,
@@ -120,14 +123,14 @@ import {
   withTemporaryHarnessProfiles,
   workspaceCheckpointSchema,
   workspaceRestoreOperationSchema
-} from "./cli-entry-1gfg3brj.js";
+} from "./cli-entry-9c2k0zwz.js";
 import {
   BUN_ENGINE_RANGE,
   HARNESS_VERSION,
   NODE_ENGINE_RANGE,
   formatCliHelp,
   shortCliHelp
-} from "./cli-entry-bx3vjw7h.js";
+} from "./cli-entry-4k1cf0m3.js";
 import {
   DEFAULT_HARNESS_MAX_STEPS,
   DEFAULT_PROVIDER_REGISTRY,
@@ -315,6 +318,8 @@ Options (automation and advanced configuration):
   --state-dir <path>             Durable run-state directory
   --mcp-config <path>            Declarative governed MCP JSON configuration
   --context-config <path>        Project context/rules/skills manifest (default: .zhivex/harness.json)
+  --no-memory                   Disable project-memory retrieval for this invocation
+  --source <text>               Provenance label for explicit memory input
   --no-project-context           Disable AGENTS.md and the project context manifest
   --patch <path>                 Exact patch/artifact bytes bound to a change envelope
   --preconditions <path>         Verification preconditions JSON for changes verify
@@ -1432,6 +1437,7 @@ Stopping the active operation; waiting for durable state and cleanup.
   let session = selectedSession ?? await sessionStore.create();
   let messages = [];
   let retainedTasks = [];
+  let retainedResponses = [];
   let persistenceHarness;
   const latestState = async (selected) => {
     const latest = selected.runs.at(-1);
@@ -1461,6 +1467,7 @@ Stopping the active operation; waiting for durable state and cleanup.
       routes = readHarnessResumeRoutes(restored);
       messages = restored.messages;
       retainedTasks = taskSources(restored.metadata);
+      retainedResponses = restored.metadata?.zhivexAssistantResponses ?? [];
     }
     harness = (await createConfiguredHarness(runtimeOptions, [], routes, credentials)).harness;
     persistenceHarness = harness;
@@ -1550,6 +1557,7 @@ Stopping the active operation; waiting for durable state and cleanup.
     activityHistory.clear();
     messages = state?.messages ?? [];
     retainedTasks = taskSources(state?.metadata);
+    retainedResponses = state?.metadata?.zhivexAssistantResponses ?? [];
   };
   const continuePendingApproval = async (approve) => {
     const current = await refreshSession();
@@ -1616,6 +1624,7 @@ Stopping the active operation; waiting for durable state and cleanup.
 `);
     messages = result.messages;
     retainedTasks = taskSources(result.state.metadata);
+    retainedResponses = result.state.metadata?.zhivexAssistantResponses ?? [];
     session = await sessionStore.updateRun(session.sessionId, state.runId, {
       status: sessionStatus(result.status)
     });
@@ -1895,6 +1904,7 @@ ${summarizeApproval(approval)}
         if (command === "/clear") {
           messages = [];
           retainedTasks = [];
+          retainedResponses = [];
           attachments.clear();
           readline.clearHistory();
           activityHistory.clear();
@@ -2178,6 +2188,7 @@ ${sanitizeTerminalText(prompt)}
             metadata: {
               ...createHarnessResumeMetadata(harness.config, routes),
               [TASK_SOURCE_KEY]: retainedTasks,
+              zhivexAssistantResponses: retainedResponses,
               zhivexCliSession: {
                 schemaVersion: 1,
                 sessionId: session.sessionId,
@@ -2196,6 +2207,7 @@ ${sanitizeTerminalText(prompt)}
             metadata: {
               ...createHarnessResumeMetadata(harness.config, routes),
               [TASK_SOURCE_KEY]: retainedTasks,
+              zhivexAssistantResponses: retainedResponses,
               zhivexCliSession: {
                 schemaVersion: 1,
                 sessionId: session.sessionId,
@@ -2224,6 +2236,7 @@ ${sanitizeTerminalText(prompt)}
           if (durable) {
             messages = durable.messages;
             retainedTasks = taskSources(durable.metadata);
+            retainedResponses = durable.metadata?.zhivexAssistantResponses ?? [];
           }
           throw error;
         }
@@ -2239,6 +2252,7 @@ ${sanitizeTerminalText(prompt)}
 `);
         messages = result.messages;
         retainedTasks = taskSources(result.state.metadata);
+        retainedResponses = result.state.metadata?.zhivexAssistantResponses ?? [];
         attachments.clear();
         process.stderr.write(formatUsageLedger(result.state.metadata?.[USAGE_LEDGER_KEY]) + `
 `);
@@ -2425,7 +2439,7 @@ ${summarizeApproval(approval)}
       ])],
       subagentModels: createHarnessRouteModels(persistedRoutes),
       store: persistence.store,
-      memory: persistence.memory,
+      projectMemory: options.projectMemory ?? true,
       onTelemetryEvent: orchestrationObserver(options.json || options.jsonl)
     });
     const approve = options.approve;
@@ -3152,6 +3166,82 @@ var manageChanges = async (options) => {
     process.exitCode = CLI_EXIT_CODES.runtimeError;
 };
 
+// src/persistence/project-memory-command.ts
+async function executeHarnessMemoryCommand(options, command, args, source = "Explicit operator input") {
+  const counts = {
+    remember: 1,
+    list: 0,
+    read: 1,
+    update: 3,
+    forget: 2,
+    suggest: 1,
+    accept: 2,
+    clear: 0,
+    enable: 0,
+    disable: 0,
+    context: 1
+  };
+  if (!Object.hasOwn(counts, command) || args.length !== counts[command])
+    throw new HarnessConfigError("Invalid memory command arguments. Use memory --help.");
+  const memory = await openHarnessProjectMemory(options);
+  try {
+    let result;
+    switch (command) {
+      case "list":
+        result = memory.list();
+        break;
+      case "read":
+        result = memory.read(args[0]);
+        break;
+      case "remember":
+        result = memory.remember({ content: args[0], source });
+        break;
+      case "suggest":
+        result = memory.suggest({ content: args[0], source });
+        break;
+      case "update":
+        result = memory.update(args[0], Number(args[1]), { content: args[2], source });
+        break;
+      case "accept":
+        result = memory.accept(args[0], Number(args[1]));
+        break;
+      case "forget":
+        memory.forget(args[0], Number(args[1]));
+        result = { forgotten: args[0] };
+        break;
+      case "clear":
+        result = { cleared: memory.clear() };
+        break;
+      case "enable":
+      case "disable":
+        memory.setEnabled(command === "enable");
+        result = { enabled: command === "enable" };
+        break;
+      case "context":
+        result = memory.retrieve(args[0]);
+        break;
+    }
+    const view = memory.list();
+    return {
+      schemaVersion: 1,
+      kind: "memory-command",
+      command,
+      workspaceKey: view.workspaceKey,
+      scopeKey: view.scopeKey,
+      result
+    };
+  } finally {
+    memory.close();
+  }
+}
+
+// src/cli/memory.ts
+async function manageMemory(options) {
+  const document = await executeHarnessMemoryCommand(resolveHarnessConfig(options), options.memoryCommand, options.memoryArguments ?? [], options.memorySource);
+  process.stdout.write(`${JSON.stringify(document, null, 2)}
+`);
+}
+
 // src/persistence/state-backup-stream.ts
 var MAGIC = `ZHIVEX-STATE-SEGMENTS-1
 `;
@@ -3322,13 +3412,24 @@ async function readBackupTransport(source, legacyMaxBytes) {
 }
 
 // src/persistence/state-backup.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
 import { constants as fsConstants2 } from "node:fs";
 import { chmod, link, lstat as lstat2, open, realpath, unlink } from "node:fs/promises";
 import path4 from "node:path";
 import { z as z3 } from "zod";
 import { normalizeAgentRunState } from "@zhivex-ai/agents";
 import { createSqliteAgentRunStore } from "@zhivex-ai/agents/ops";
+
+// src/persistence/sdk-store-identity.ts
+import { createHash as createHash4 } from "node:crypto";
+var sdkCanonicalKey = (kind, scope, value) => `${kind}:v2:${createHash4("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"]);
@@ -3383,6 +3484,8 @@ var memoryRecordSchema = z3.object({
   messages: z3.array(z3.unknown()),
   updatedAt: z3.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 = z3.object({
   sessionId: z3.string().min(1).max(260),
   workspaceKey: bindingKeySchema,
@@ -3464,12 +3567,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 = createHash4("sha256");
+  const hash = createHash5("sha256");
   for (const chunk of canonicalChunks(payload))
     hash.update(chunk);
   return `sha256:${hash.digest("hex")}`;
 };
-var stableKey = (kind, value) => createHash4("sha256").update(kind).update("\x00").update(value).digest("hex");
+var stableKey = (kind, value) => createHash5("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) => {
@@ -3481,7 +3584,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] : [];
@@ -3489,7 +3591,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}`);
@@ -3667,12 +3769,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: z3.array(z3.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 = z3.strictObject({ schemaVersion: z3.literal(1), memoryKey: z3.literal(row.memory_key), messages: z3.array(z3.unknown()) }).parse(value);
+        return { key: row.memory_key, messages: envelope.messages, updatedAt: row.updated_at_ms };
+      }
+      return { key: row.memory_key, messages: z3.array(z3.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));
@@ -3865,7 +3971,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.`);
     }
   }
@@ -3884,7 +3990,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);
@@ -3896,7 +4002,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.");
     }
   }
@@ -3908,9 +4014,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);
@@ -3952,7 +4061,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:${createHash4("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:${createHash5("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") {
@@ -4049,9 +4158,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) : [])
@@ -4077,7 +4186,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,
@@ -4360,7 +4469,7 @@ var main = async (argv = process.argv.slice(2)) => {
     parsedOptions = { ...parsedOptions, prompt: await readStdinTask() };
   }
   if (parsedOptions.serviceFile) {
-    const { runServiceCli } = await import("./service-client-cli-3365rfav.js");
+    const { runServiceCli } = await import("./service-client-cli-b52c67hx.js");
     await runServiceCli(parsedOptions, annotateCliStreamError);
     return;
   }
@@ -4417,6 +4526,9 @@ var main = async (argv = process.argv.slice(2)) => {
     case "changes":
       await manageChanges(options);
       return;
+    case "memory":
+      await manageMemory(options);
+      return;
     case "state":
       await manageState(options);
       return;

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   HARNESS_VERSION,
   shortCliHelp
-} from "./cli-entry-bx3vjw7h.js";
+} from "./cli-entry-4k1cf0m3.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -16,6 +16,6 @@ if (argv.length === 1 && ["--version", "-v", "version"].includes(argv[0])) {
   process.stdout.write(`${shortCliHelp(HARNESS_VERSION)}
 `);
 } else {
-  const { runCli } = await import("./cli-etsmtst3.js");
+  const { runCli } = await import("./cli-s1rs15vv.js");
   await runCli(argv);
 }

package/dist/client/check-evidence.d.ts

@@ -0,0 +1,17 @@
+/** Redacted observation only: no argv, inputs, stdout, stderr or pass claims for a task. */
+export declare function checkEvidence(results: readonly {
+    toolName: string;
+    output?: unknown;
+    isError?: boolean;
+}[]): {
+    coverage: 'recorded-checks-only';
+    receipts: {
+        toolName: string;
+        exitCode: number;
+        timedOut: boolean;
+        passed: boolean;
+    }[];
+    passed: number;
+    failed: number;
+    taskVerified: false;
+};

package/dist/client/run-document.d.ts

@@ -10,6 +10,18 @@ export declare const runResultDocument: (result: AgentRunOutput, harness: Zhivex
     output: string;
     steps: number;
     toolCalls: number;
+    verification: {
+        coverage: 'recorded-checks-only';
+        receipts: {
+            toolName: string;
+            exitCode: number;
+            timedOut: boolean;
+            passed: boolean;
+        }[];
+        passed: number;
+        failed: number;
+        taskVerified: false;
+    };
     mutations: readonly {
         id: string;
         operation: "create" | "move" | "quarantine" | "restore" | "update";

package/dist/compat/cli-options.d.ts

@@ -8,7 +8,7 @@ export interface CliCommandOptionContract {
     repeatable: readonly string[];
     conflicts: Readonly<Record<string, readonly string[]>>;
 }
-export declare const CLI_OPTION_NAMES: readonly ["--compaction-model", "--compaction-provider", "--provider", "--model", "--reasoning", "--profile", "--route", "--workspace", "--state-dir", "--mcp-config", "--context-config", "--no-project-context", "--patch", "--preconditions", "--now", "--require-verified-delivery", "--execution", "--oci-runtime", "--oci-image", "--oci-allow-command", "--oci-shell", "--oci-max-process-runtime-ms", "--oci-max-process-output-bytes", "--oci-max-memory-mb", "--oci-max-pids", "--oci-max-cpus", "--oci-max-workspace-bytes", "--oci-max-file-write-bytes", "--oci-tmpfs-mb", "--store", "--tenant", "--user", "--namespace", "--idempotency-key", "--token-budget", "--context-tokens", "--no-token-budget", "--max-steps", "--timeout-ms", "--max-tool-calls", "--max-tool-errors", "--max-input-tokens", "--max-output-tokens", "--max-total-tokens", "--subagent-max-steps", "--subagent-max-tool-calls", "--subagent-max-tool-errors", "--subagent-max-input-tokens", "--subagent-max-output-tokens", "--subagent-max-total-tokens", "--subagent-timeout-ms", "--max-parallel-reviews", "--max-cost-usd", "--input-cost-per-million", "--output-cost-per-million", "--allow-check", "--require-capability", "--subagent", "--reviewer", "--approval-mode", "--yes", "--approve", "--deny", "--json", "--jsonl", "--session", "--continue", "--update", "--status", "--limit", "--cursor", "--before", "--reason", "--cascade", "--final", "--service", "--apply", "--help", "--version", "--search", "--tool-policy", "--pricing-file", "--usage-limit-usd"];
+export declare const CLI_OPTION_NAMES: readonly ["--compaction-model", "--compaction-provider", "--provider", "--model", "--reasoning", "--profile", "--route", "--workspace", "--state-dir", "--mcp-config", "--no-memory", "--source", "--context-config", "--no-project-context", "--patch", "--preconditions", "--now", "--require-verified-delivery", "--execution", "--oci-runtime", "--oci-image", "--oci-allow-command", "--oci-shell", "--oci-max-process-runtime-ms", "--oci-max-process-output-bytes", "--oci-max-memory-mb", "--oci-max-pids", "--oci-max-cpus", "--oci-max-workspace-bytes", "--oci-max-file-write-bytes", "--oci-tmpfs-mb", "--store", "--tenant", "--user", "--namespace", "--idempotency-key", "--token-budget", "--context-tokens", "--no-token-budget", "--max-steps", "--timeout-ms", "--max-tool-calls", "--max-tool-errors", "--max-input-tokens", "--max-output-tokens", "--max-total-tokens", "--subagent-max-steps", "--subagent-max-tool-calls", "--subagent-max-tool-errors", "--subagent-max-input-tokens", "--subagent-max-output-tokens", "--subagent-max-total-tokens", "--subagent-timeout-ms", "--max-parallel-reviews", "--max-cost-usd", "--input-cost-per-million", "--output-cost-per-million", "--allow-check", "--require-capability", "--subagent", "--reviewer", "--approval-mode", "--yes", "--approve", "--deny", "--json", "--jsonl", "--session", "--continue", "--update", "--status", "--limit", "--cursor", "--before", "--reason", "--cascade", "--final", "--service", "--apply", "--help", "--version", "--search", "--tool-policy", "--pricing-file", "--usage-limit-usd"];
 export type CliOptionName = (typeof CLI_OPTION_NAMES)[number];
 export declare const CLI_OPTION_DEFINITIONS: Readonly<Record<CliOptionName, CliOptionDefinition>>;
 export declare const CLI_COMMAND_OPTION_CONTRACTS: {
@@ -43,6 +43,17 @@ export declare const CLI_COMMAND_OPTION_CONTRACTS: {
     readonly "checkpoints:recover": CliCommandOptionContract;
     readonly "changes:create": CliCommandOptionContract;
     readonly "changes:verify": CliCommandOptionContract;
+    readonly "memory:remember": CliCommandOptionContract;
+    readonly "memory:suggest": CliCommandOptionContract;
+    readonly "memory:list": CliCommandOptionContract;
+    readonly "memory:read": CliCommandOptionContract;
+    readonly "memory:update": CliCommandOptionContract;
+    readonly "memory:forget": CliCommandOptionContract;
+    readonly "memory:accept": CliCommandOptionContract;
+    readonly "memory:clear": CliCommandOptionContract;
+    readonly "memory:enable": CliCommandOptionContract;
+    readonly "memory:disable": CliCommandOptionContract;
+    readonly "memory:context": CliCommandOptionContract;
     readonly "state:status": CliCommandOptionContract;
     readonly "state:export": CliCommandOptionContract;
     readonly "state:import": CliCommandOptionContract;

package/dist/compat/code-support.d.ts

@@ -20,3 +20,7 @@ export { inspectRuntimeDiagnostics } from "../runtime/runtime-diagnostics.js";
 export { harnessToolExecution } from "../runtime/tool-execution.js";
 export { USAGE_LEDGER_KEY, formatUsageLedger, inspectUsageLedger, usagePricingSchema } from "../runtime/usage-ledger.js";
 export { FileChangedWhileReadingError, FileSizeLimitError, UnsafeFileTypeError, readRegularFileNoFollow } from "../workspace/file-security.js";
+export { resolvePackageCheckCommand } from "../execution/package-manager.js";
+export { nativeTaskSnapshot } from "../runtime/task-acceptance-native.js";
+export { TASK_ACCEPTANCE_EVIDENCE_KEY } from "../runtime/task-acceptance-record.js";
+export { checkEvidence } from "../client/check-evidence.js";

package/dist/compat/code-support.js

@@ -2,9 +2,12 @@ import {
   loadModelCatalog
 } from "../index-wg1sd3at.js";
 import {
-  estimateMessages
-} from "../index-8zzhggxv.js";
+  checkEvidence,
+  estimateMessages,
+  nativeTaskSnapshot
+} from "../index-a1q355va.js";
 import {
+  TASK_ACCEPTANCE_EVIDENCE_KEY,
   TASK_SOURCE_KEY,
   USAGE_LEDGER_KEY,
   formatUsageLedger,
@@ -13,16 +16,17 @@ import {
   inspectUsageLedger,
   taskSources,
   usagePricingSchema
-} from "../index-42gp2hy8.js";
+} from "../index-vtqfjnab.js";
 import {
   FileChangedWhileReadingError,
   FileSizeLimitError,
   SqliteDatabase,
   UnsafeFileTypeError,
   readRegularFileNoFollow,
+  resolvePackageCheckCommand,
   resolvePackageManager,
   runPortableProcess
-} from "../index-yb239ghk.js";
+} from "../index-r0tdj04h.js";
 import {
   DEFAULT_HARNESS_MAX_STEPS,
   modelReasoningEfforts,
@@ -51,11 +55,13 @@ export {
   DEFAULT_HARNESS_MAX_STEPS,
   FileChangedWhileReadingError,
   FileSizeLimitError,
+  TASK_ACCEPTANCE_EVIDENCE_KEY,
   TASK_SOURCE_KEY,
   USAGE_LEDGER_KEY,
   UnsafeFileTypeError,
   bundledModelCatalog,
   catalogModels,
+  checkEvidence,
   estimateMessages,
   formatUsageLedger,
   harnessToolExecution,
@@ -65,8 +71,10 @@ export {
   loadModelCatalog,
   modelDescription,
   modelReasoningEfforts,
+  nativeTaskSnapshot,
   readRegularFileNoFollow,
   reasoningEffortSchema,
+  resolvePackageCheckCommand,
   resolvePackageManager,
   runPortableProcess,
   taskSources,

package/dist/context/compaction.d.ts

@@ -11,4 +11,9 @@ export declare const compactedTaskSources: (messages: readonly ModelMessage[]) =
     text: string;
     original?: true;
 }[] | undefined;
+export declare const compactedAssistantResponses: (messages: readonly ModelMessage[]) => {
+    id: string;
+    text: string;
+    truncated: boolean;
+}[] | undefined;
 export declare const compactMessages: (messages: readonly ModelMessage[]) => ModelMessage[];

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

@@ -0,0 +1,6 @@
+import type { LanguageModelMiddleware } from "@zhivex-ai/core";
+import type { HarnessProjectMemory } from "../persistence/project-memory.js";
+/** Per-request projection; memory text never enters system instructions or durable
+ * run messages. Reload for every request so edits, forgetting and opt-out apply
+ * even to a resumed run. Existing conversation history has its own retention. */
+export declare function createProjectMemoryMiddleware(memory: HarnessProjectMemory): LanguageModelMiddleware;

package/dist/context/task-memory.d.ts

@@ -1,6 +1,17 @@
 import { type ModelMessage } from "@zhivex-ai/core";
 import { z } from "zod";
 export declare const TASK_SOURCE_KEY = "zhivexTaskSources";
+export declare const ASSISTANT_RESPONSE_KEY = "zhivexAssistantResponses";
+export declare const MAX_ASSISTANT_RESPONSES = 3;
+export declare const MAX_ASSISTANT_RESPONSE_CHARACTERS = 64000;
+type AssistantResponse = {
+    id: string;
+    text: string;
+    truncated: boolean;
+};
+/** Bounded, untrusted assistant text. Never an operator source or acceptance ledger. */
+export declare const assistantResponses: (metadata: unknown) => AssistantResponse[];
+export declare const captureAssistantResponses: (metadata: unknown, messages: readonly ModelMessage[]) => AssistantResponse[];
 type TaskSource = {
     id: string;
     text: string;
@@ -11,10 +22,31 @@ export declare const taskSources: (metadata: unknown) => TaskSource[];
 export declare const captureTaskSources: (metadata: unknown, messages: readonly ModelMessage[]) => TaskSource[];
 export declare const createTaskTools: () => {
     read_task: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<{
+            assistant_response: "assistant_response";
+            operator: "operator";
+        }>>;
+        query: z.ZodOptional<z.ZodString>;
         id: z.ZodOptional<z.ZodString>;
-        offset: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
         sourceOffset: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, {
+        source: string;
+        untrusted: true;
+        verified: false;
+        id: string;
+        sourceIds: string[];
+        totalSources: number;
+        truncated: boolean;
+        content: string;
+        offset: number;
+        totalCharacters: number;
+        nextOffset: number | null;
+    } | {
+        source?: never;
+        untrusted?: never;
+        verified?: never;
+        truncated?: never;
         id: string;
         sourceIds: string[];
         acceptance?: import("@zhivex-ai/core").JsonValue;

package/dist/engine/acp.js

@@ -2,7 +2,7 @@ import {
   discardMcpWorkspaceSnapshot,
   launchDockerMcpGroup,
   prepareMcpWorkspaceSnapshot
-} from "../index-6m08wvab.js";
+} from "../index-2tgb2b4e.js";
 import {
   createAcpConnection,
   issueAcpMcpSessionProvider,
@@ -11,13 +11,13 @@ import {
 import {
   createHarness,
   createHarnessClientAdapter
-} from "../index-hnaxfpb5.js";
-import"../index-h0mqx2ed.js";
-import"../index-8zzhggxv.js";
-import"../index-42gp2hy8.js";
-import"../index-azmwjp95.js";
-import"../index-z0qxmkm2.js";
-import"../index-yb239ghk.js";
+} from "../index-4j1h4j8c.js";
+import"../index-rd0s3gqj.js";
+import"../index-a1q355va.js";
+import"../index-vtqfjnab.js";
+import"../index-0g939pfs.js";
+import"../index-e6r04a18.js";
+import"../index-r0tdj04h.js";
 import"../index-gq9xagx2.js";
 import"../index-8705zxpr.js";
 import"../index-xqxeypt5.js";