@zhivex-ai/harness 0.6.1 → 0.7.0

package/dist/cli.js

@@ -3,21 +3,369 @@
 
 // src/cli.ts
 import { createInterface } from "readline/promises";
+import { randomUUID as randomUUID5 } from "crypto";
 import { constants as fsConstants } from "fs";
-import { access, lstat as lstat6, readFile as readFile4, stat as stat3 } from "fs/promises";
-import path8 from "path";
+import { access, lstat as lstat7, readFile as readFile4, stat as stat4 } from "fs/promises";
+import path9 from "path";
 import {
   getAgentBudgetStatus as getAgentBudgetStatus3
 } from "@zhivex-ai/agents";
 
 // src/config.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { realpathSync } from "fs";
 import path from "path";
+
+// src/providers.ts
+import { createHash } from "crypto";
+import { createGemini } from "@zhivex-ai/gemini";
 import { createMeta } from "@zhivex-ai/meta";
 import { createOpenAI } from "@zhivex-ai/openai";
 import { createQwen } from "@zhivex-ai/qwen";
-var PROVIDERS = ["meta", "qwen", "openai"];
+var PROVIDERS = ["meta", "qwen", "openai", "gemini"];
+var HARNESS_PROVIDER_CAPABILITIES = [
+  "streaming",
+  "tool-calling",
+  "approval-resume"
+];
+var QWEN_REGIONS = [
+  "singapore",
+  "beijing",
+  "hong-kong",
+  "tokyo",
+  "frankfurt",
+  "virginia"
+];
+var PROVIDER_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+var ENVIRONMENT_VARIABLE = /^[A-Z_][A-Z0-9_]{0,127}$/;
+var DIAGNOSTIC_KEY = /^[a-z][A-Za-z0-9]{0,63}$/;
+var requiredText = (name, value) => {
+  const normalized = value.trim();
+  if (!normalized || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new Error(`${name} must be a non-empty printable string.`);
+  }
+  return normalized;
+};
+var environmentVariable = (name, value) => {
+  if (!ENVIRONMENT_VARIABLE.test(value)) {
+    throw new Error(`${name} must be a valid environment variable name.`);
+  }
+  return value;
+};
+var diagnosticKey = (value) => {
+  if (!DIAGNOSTIC_KEY.test(value)) {
+    throw new Error(`Invalid provider diagnostic key: ${value}.`);
+  }
+  return value;
+};
+var normalizedDescriptor = (descriptor) => {
+  const id = descriptor.id.trim().toLowerCase();
+  if (descriptor.id !== id || !PROVIDER_ID.test(id)) {
+    throw new Error(`Invalid provider id: ${descriptor.id}. Use 1-64 lowercase letters, digits, dot, underscore, or hyphen.`);
+  }
+  if (!(descriptor.support === "certified" || descriptor.support === "provisional")) {
+    throw new Error(`Invalid support level for provider ${id}.`);
+  }
+  const credentialNames = [...new Set(descriptor.credentialNames.map((name) => environmentVariable(`Credential for provider ${id}`, name)))];
+  const capabilities = [...new Set(descriptor.capabilities)];
+  const invalidCapability = capabilities.find((capability) => !HARNESS_PROVIDER_CAPABILITIES.includes(capability));
+  if (invalidCapability) {
+    throw new Error(`Invalid capability for provider ${id}: ${invalidCapability}.`);
+  }
+  return Object.freeze({
+    id,
+    name: requiredText(`Name for provider ${id}`, descriptor.name),
+    defaultModel: requiredText(`Default model for provider ${id}`, descriptor.defaultModel),
+    credentialNames: Object.freeze(credentialNames),
+    capabilities: Object.freeze(capabilities),
+    support: descriptor.support
+  });
+};
+var normalizedDiagnostics = (provider, diagnostics) => {
+  const endpointEnvironmentVariable = diagnostics?.endpointEnvironmentVariable === undefined ? undefined : environmentVariable(`Endpoint diagnostic for provider ${provider}`, diagnostics.endpointEnvironmentVariable);
+  const seenKeys = new Set;
+  const presence = (diagnostics?.presence ?? []).map((entry) => {
+    const key = diagnosticKey(entry.key);
+    if (seenKeys.has(key)) {
+      throw new Error(`Duplicate diagnostic key for provider ${provider}: ${key}.`);
+    }
+    seenKeys.add(key);
+    return Object.freeze({
+      key,
+      environmentVariable: environmentVariable(`Presence diagnostic for provider ${provider}`, entry.environmentVariable)
+    });
+  });
+  const enums = (diagnostics?.enums ?? []).map((entry) => {
+    const key = diagnosticKey(entry.key);
+    if (seenKeys.has(key)) {
+      throw new Error(`Duplicate diagnostic key for provider ${provider}: ${key}.`);
+    }
+    seenKeys.add(key);
+    const allowedValues = [...new Set(entry.allowedValues.map((value) => requiredText(`Allowed diagnostic value for provider ${provider}`, value)))];
+    if (allowedValues.length === 0) {
+      throw new Error(`Enum diagnostic ${key} for provider ${provider} needs allowed values.`);
+    }
+    return Object.freeze({
+      key,
+      environmentVariable: environmentVariable(`Enum diagnostic for provider ${provider}`, entry.environmentVariable),
+      allowedValues: Object.freeze(allowedValues)
+    });
+  });
+  return Object.freeze({
+    ...endpointEnvironmentVariable ? { endpointEnvironmentVariable } : {},
+    ...presence.length > 0 ? { presence: Object.freeze(presence) } : {},
+    ...enums.length > 0 ? { enums: Object.freeze(enums) } : {}
+  });
+};
+var endpointConfiguration = (value) => {
+  const configured = Boolean(value?.trim());
+  if (!configured) {
+    return {
+      customEndpoint: false,
+      endpointValid: true,
+      endpointSecure: true
+    };
+  }
+  try {
+    const endpoint = new URL(value.trim());
+    const supportedProtocol = endpoint.protocol === "https:" || endpoint.protocol === "http:";
+    return {
+      customEndpoint: true,
+      endpointValid: supportedProtocol && !endpoint.username && !endpoint.password && !endpoint.hash && !endpoint.search,
+      endpointSecure: endpoint.protocol === "https:"
+    };
+  } catch {
+    return {
+      customEndpoint: true,
+      endpointValid: false,
+      endpointSecure: false
+    };
+  }
+};
+var createCredentials = (env, provider, names) => Object.freeze({
+  names,
+  get: (name) => {
+    if (!names.includes(name)) {
+      throw new Error(`Credential ${name} is not declared for provider ${provider}.`);
+    }
+    return env[name]?.trim() || undefined;
+  },
+  first: () => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    return;
+  },
+  require: () => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    throw new Error(names.length === 0 ? `Provider ${provider} does not declare a credential.` : `Missing credentials for ${provider}. Set ${names.join(" or ")} in the environment.`);
+  }
+});
+var normalizeRegistration = (registration) => {
+  if (typeof registration.factory !== "function") {
+    throw new Error("Provider registration factory must be a function.");
+  }
+  const descriptor = normalizedDescriptor(registration.descriptor);
+  return Object.freeze({
+    descriptor,
+    factory: registration.factory,
+    diagnostics: normalizedDiagnostics(descriptor.id, registration.diagnostics)
+  });
+};
+var providerConfiguration = (diagnostics, env) => {
+  const configuration = endpointConfiguration(diagnostics.endpointEnvironmentVariable ? env[diagnostics.endpointEnvironmentVariable] : undefined);
+  for (const entry of diagnostics.presence ?? []) {
+    configuration[`${entry.key}Configured`] = Boolean(env[entry.environmentVariable]?.trim());
+  }
+  for (const entry of diagnostics.enums ?? []) {
+    const value = env[entry.environmentVariable]?.trim();
+    configuration[`${entry.key}Configured`] = Boolean(value);
+    configuration[`${entry.key}Valid`] = !value || entry.allowedValues.includes(value);
+  }
+  return Object.freeze(configuration);
+};
+var parseWithRegistrations = (value, registrations) => {
+  const defaultProvider = registrations.has("openai") ? "openai" : registrations.keys().next().value;
+  const normalized = (value ?? defaultProvider ?? "").trim().toLowerCase();
+  if (registrations.has(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Unknown provider: ${value}. Use ${[...registrations.keys()].join(", ")}.`);
+};
+var createProviderRegistry = (registrations) => {
+  if (registrations.length === 0) {
+    throw new Error("Provider registry must contain at least one provider.");
+  }
+  const entries = new Map;
+  for (const registration of registrations) {
+    const normalized = normalizeRegistration(registration);
+    if (entries.has(normalized.descriptor.id)) {
+      throw new Error(`Duplicate provider registration: ${normalized.descriptor.id}.`);
+    }
+    entries.set(normalized.descriptor.id, normalized);
+  }
+  const frozenRegistrations = Object.freeze([...entries.values()]);
+  const descriptors = Object.freeze(frozenRegistrations.map((entry) => entry.descriptor));
+  const registry = Object.freeze({
+    descriptors,
+    has: (provider) => entries.has(provider.trim().toLowerCase()),
+    parse: (value) => parseWithRegistrations(value, entries),
+    descriptor: (provider) => {
+      const registration = entries.get(provider);
+      if (!registration) {
+        throw new Error(`No descriptor is available for provider ${provider}.`);
+      }
+      return registration.descriptor;
+    },
+    createModel: (config, env = process.env) => {
+      const registration = entries.get(config.provider);
+      if (!registration) {
+        throw new Error(`No factory is available for provider ${config.provider}.`);
+      }
+      return registration.factory(Object.freeze({
+        provider: config.provider,
+        model: config.model,
+        env,
+        credentials: createCredentials(env, config.provider, registration.descriptor.credentialNames)
+      }));
+    },
+    availability: (env = process.env) => Object.freeze(frozenRegistrations.map((registration) => {
+      const credentials = Object.freeze(registration.descriptor.credentialNames.map((name) => Object.freeze({ name, present: Boolean(env[name]?.trim()) })));
+      return Object.freeze({
+        ...registration.descriptor,
+        configured: credentials.length === 0 || credentials.some((credential) => credential.present),
+        credentials,
+        configuration: providerConfiguration(registration.diagnostics, env)
+      });
+    })),
+    transportFingerprint: (env = process.env) => {
+      const transport = frozenRegistrations.map((registration) => {
+        const names = [
+          registration.diagnostics.endpointEnvironmentVariable,
+          ...(registration.diagnostics.presence ?? []).map((entry) => entry.environmentVariable),
+          ...(registration.diagnostics.enums ?? []).map((entry) => entry.environmentVariable)
+        ].filter((name) => Boolean(name));
+        return {
+          provider: registration.descriptor.id,
+          values: names.map((name) => [name, env[name]?.trim() ?? ""])
+        };
+      });
+      return `sha256:${createHash("sha256").update(JSON.stringify(transport)).digest("hex")}`;
+    },
+    extend: (additional) => createProviderRegistry([
+      ...frozenRegistrations,
+      ...additional
+    ])
+  });
+  return registry;
+};
+var optionalQwenRegion = (value) => {
+  if (!value) {
+    return;
+  }
+  if (QWEN_REGIONS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid QWEN_REGION: ${value}.`);
+};
+var BUILTIN_PROVIDER_REGISTRATIONS = Object.freeze([
+  {
+    descriptor: {
+      id: "meta",
+      name: "Meta Model API",
+      defaultModel: "muse-spark-1.2",
+      credentialNames: ["MODEL_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: { endpointEnvironmentVariable: "META_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.META_BASE_URL?.trim();
+      return createMeta({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  },
+  {
+    descriptor: {
+      id: "qwen",
+      name: "Qwen / Alibaba Cloud Model Studio",
+      defaultModel: "qwen3.8-max",
+      credentialNames: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: {
+      endpointEnvironmentVariable: "QWEN_BASE_URL",
+      presence: [{ key: "workspaceId", environmentVariable: "QWEN_WORKSPACE_ID" }],
+      enums: [{
+        key: "region",
+        environmentVariable: "QWEN_REGION",
+        allowedValues: QWEN_REGIONS
+      }]
+    },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.QWEN_BASE_URL?.trim();
+      const workspaceId = env.QWEN_WORKSPACE_ID?.trim();
+      const region = optionalQwenRegion(env.QWEN_REGION?.trim());
+      return createQwen({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {},
+        ...workspaceId ? { workspaceId } : {},
+        ...region ? { region } : {}
+      })(model);
+    }
+  },
+  {
+    descriptor: {
+      id: "openai",
+      name: "OpenAI",
+      defaultModel: "gpt-5.4",
+      credentialNames: ["OPENAI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: { endpointEnvironmentVariable: "OPENAI_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.OPENAI_BASE_URL?.trim();
+      return createOpenAI({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  },
+  {
+    descriptor: {
+      id: "gemini",
+      name: "Google Gemini",
+      defaultModel: "gemini-3.6-flash",
+      credentialNames: ["GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: { endpointEnvironmentVariable: "GEMINI_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.GEMINI_BASE_URL?.trim();
+      return createGemini({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  }
+]);
+var DEFAULT_PROVIDER_REGISTRY = createProviderRegistry(BUILTIN_PROVIDER_REGISTRATIONS);
+var PROVIDER_DESCRIPTORS = DEFAULT_PROVIDER_REGISTRY.descriptors;
+
+// src/config.ts
 var DEFAULT_ALLOWED_CHECKS = ["test", "typecheck", "lint", "build"];
 var HARNESS_CONFIG_SCHEMA_VERSION = 4;
 var HARNESS_STORE_BACKENDS = ["sqlite", "file"];
@@ -73,45 +421,6 @@ var DEFAULT_SUBAGENT_BUDGET = {
   maxTotalTokens: 36000,
   includeChildRuns: false
 };
-var HARNESS_PROVIDER_CAPABILITIES = [
-  "streaming",
-  "tool-calling",
-  "approval-resume"
-];
-var PROVIDER_DESCRIPTORS = [
-  {
-    id: "meta",
-    name: "Meta Model API",
-    defaultModel: "muse-spark-1.2",
-    credentialNames: ["MODEL_API_KEY"],
-    capabilities: HARNESS_PROVIDER_CAPABILITIES,
-    support: "certified"
-  },
-  {
-    id: "qwen",
-    name: "Qwen / Alibaba Cloud Model Studio",
-    defaultModel: "qwen3.8-max",
-    credentialNames: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
-    capabilities: HARNESS_PROVIDER_CAPABILITIES,
-    support: "certified"
-  },
-  {
-    id: "openai",
-    name: "OpenAI",
-    defaultModel: "gpt-5.4",
-    credentialNames: ["OPENAI_API_KEY"],
-    capabilities: HARNESS_PROVIDER_CAPABILITIES,
-    support: "certified"
-  }
-];
-var QWEN_REGIONS = [
-  "singapore",
-  "beijing",
-  "hong-kong",
-  "tokyo",
-  "frankfurt",
-  "virginia"
-];
 var integerOption = (name, input, envValue, fallback, minimum, maximum) => {
   const value = input ?? (envValue === undefined ? fallback : Number(envValue));
   if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
@@ -140,7 +449,7 @@ var nonNegativeNumberOption = (name, input, envValue) => {
   }
   return value;
 };
-var defaultHarnessNamespace = (workspace) => `workspace-${createHash("sha256").update(workspace).digest("hex").slice(0, 16)}`;
+var defaultHarnessNamespace = (workspace) => `workspace-${createHash2("sha256").update(workspace).digest("hex").slice(0, 16)}`;
 var canonicalStateDirectory = (requestedWorkspace, canonicalWorkspace, configured) => {
   if (!configured) {
     return path.join(canonicalWorkspace, ".zhivex-harness", "runs");
@@ -242,26 +551,14 @@ var canonicalWorkspaceFile = (requestedWorkspace, canonicalWorkspace, configured
   const insideRequestedWorkspace = relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
   return insideRequestedWorkspace ? path.resolve(canonicalWorkspace, relative) : requestedPath;
 };
-var parseProvider = (value) => {
-  const normalized = (value ?? "openai").trim().toLowerCase();
-  if (PROVIDERS.includes(normalized)) {
-    return normalized;
-  }
-  throw new Error(`Unknown provider: ${value}. Use meta, qwen, or openai.`);
-};
-var providerDescriptor = (provider) => {
-  const descriptor = PROVIDER_DESCRIPTORS.find((entry) => entry.id === provider);
-  if (!descriptor) {
-    throw new Error(`No descriptor is available for provider ${provider}.`);
-  }
-  return descriptor;
-};
-var resolveHarnessConfig = (input = {}) => {
+var parseProvider = (value, registry = DEFAULT_PROVIDER_REGISTRY) => registry.parse(value);
+var providerDescriptor = (provider, registry = DEFAULT_PROVIDER_REGISTRY) => registry.descriptor(provider);
+var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) => {
   if (input.schemaVersion !== undefined && input.schemaVersion !== HARNESS_CONFIG_SCHEMA_VERSION) {
     throw new Error(`Unsupported config schema version: ${input.schemaVersion}. Expected ${HARNESS_CONFIG_SCHEMA_VERSION}.`);
   }
-  const provider = parseProvider(input.provider ?? process.env.ZHIVEX_HARNESS_PROVIDER);
-  const descriptor = providerDescriptor(provider);
+  const provider = parseProvider(input.provider ?? process.env.ZHIVEX_HARNESS_PROVIDER, registry);
+  const descriptor = providerDescriptor(provider, registry);
   const requestedWorkspace = path.resolve(input.workspace ?? process.cwd());
   let workspace = requestedWorkspace;
   try {
@@ -355,105 +652,11 @@ var resolveHarnessConfig = (input = {}) => {
     ...mcpConfigPath ? { mcpConfigPath } : {}
   };
 };
-var requiredCredential = (env, provider, names) => {
-  for (const name of names) {
-    const value = env[name]?.trim();
-    if (value) {
-      return value;
-    }
-  }
-  throw new Error(`Missing credentials for ${provider}. Set ${names.join(" or ")} in the environment.`);
-};
-var optionalQwenRegion = (value) => {
-  if (!value) {
-    return;
-  }
-  if (QWEN_REGIONS.includes(value)) {
-    return value;
-  }
-  throw new Error(`Invalid QWEN_REGION: ${value}.`);
-};
-var createProviderModel = (config, env = process.env) => {
-  switch (config.provider) {
-    case "meta": {
-      const baseURL = env.META_BASE_URL?.trim();
-      const provider = createMeta({
-        apiKey: requiredCredential(env, "meta", ["MODEL_API_KEY"]),
-        ...baseURL ? { baseURL } : {}
-      });
-      return provider(config.model);
-    }
-    case "qwen": {
-      const baseURL = env.QWEN_BASE_URL?.trim();
-      const workspaceId = env.QWEN_WORKSPACE_ID?.trim();
-      const region = optionalQwenRegion(env.QWEN_REGION?.trim());
-      const provider = createQwen({
-        apiKey: requiredCredential(env, "qwen", ["DASHSCOPE_API_KEY", "QWEN_API_KEY"]),
-        ...baseURL ? { baseURL } : {},
-        ...workspaceId ? { workspaceId } : {},
-        ...region ? { region } : {}
-      });
-      return provider(config.model);
-    }
-    case "openai": {
-      const baseURL = env.OPENAI_BASE_URL?.trim();
-      const provider = createOpenAI({
-        apiKey: requiredCredential(env, "openai", ["OPENAI_API_KEY"]),
-        ...baseURL ? { baseURL } : {}
-      });
-      return provider(config.model);
-    }
-  }
-};
-var endpointConfiguration = (value) => {
-  const configured = Boolean(value?.trim());
-  if (!configured) {
-    return {
-      customEndpoint: false,
-      endpointValid: true,
-      endpointSecure: true
-    };
-  }
-  try {
-    const endpoint = new URL(value.trim());
-    const supportedProtocol = endpoint.protocol === "https:" || endpoint.protocol === "http:";
-    return {
-      customEndpoint: true,
-      endpointValid: supportedProtocol && !endpoint.username && !endpoint.password && !endpoint.hash,
-      endpointSecure: endpoint.protocol === "https:"
-    };
-  } catch {
-    return {
-      customEndpoint: true,
-      endpointValid: false,
-      endpointSecure: false
-    };
-  }
-};
-var providerAvailability = (env = process.env) => PROVIDER_DESCRIPTORS.map((descriptor) => {
-  const credentials = descriptor.credentialNames.map((name) => ({
-    name,
-    present: Boolean(env[name]?.trim())
-  }));
-  const endpointVariable = descriptor.id === "meta" ? "META_BASE_URL" : descriptor.id === "qwen" ? "QWEN_BASE_URL" : "OPENAI_BASE_URL";
-  const regionValue = descriptor.id === "qwen" ? env.QWEN_REGION?.trim() : undefined;
-  return {
-    ...descriptor,
-    configured: credentials.some((credential) => credential.present),
-    credentials,
-    configuration: {
-      ...endpointConfiguration(env[endpointVariable]),
-      ...descriptor.id === "qwen" ? {
-        workspaceIdConfigured: Boolean(env.QWEN_WORKSPACE_ID?.trim()),
-        regionConfigured: Boolean(regionValue),
-        regionValid: !regionValue || QWEN_REGIONS.includes(regionValue)
-      } : {}
-    }
-  };
-});
+var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => registry.createModel(config, env);
+var providerAvailability = (env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => registry.availability(env);
 
 // src/harness.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import {
   Agent,
   applySafetyPolicyToAgent as applySafetyPolicyToAgent2,
@@ -523,7 +726,7 @@ var selectHarnessModel = (candidates, required) => {
 };
 
 // src/edit-contracts.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import path2 from "path";
 import { z } from "zod";
 var EDIT_CONTRACT_SCHEMA_VERSION = 1;
@@ -623,7 +826,7 @@ var mutationAuditEntrySchema = z.strictObject({
   timestamp: z.iso.datetime(),
   quarantineId: z.string().min(1).max(200).optional()
 });
-var digest = (value) => `sha256:${createHash2("sha256").update(value).digest("hex")}`;
+var digest = (value) => `sha256:${createHash3("sha256").update(value).digest("hex")}`;
 var canonicalProposalPayload = (changes) => ({
   schemaVersion: EDIT_CONTRACT_SCHEMA_VERSION,
   kind: "edit-proposal",
@@ -658,7 +861,7 @@ var editContractDocument = (kind, result) => ({
 });
 
 // src/workspace.ts
-import { createHash as createHash3, randomUUID } from "crypto";
+import { createHash as createHash4, randomUUID } from "crypto";
 import { link, lstat, mkdir, open, readFile, readdir, realpath, rename, stat, unlink } from "fs/promises";
 import path3 from "path";
 var HARD_IGNORES = new Set([".git", ".next", ".turbo", ".zhivex-harness", "coverage", "dist", "node_modules"]);
@@ -676,7 +879,7 @@ var isInside = (root, candidate) => {
   return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
 };
 var wirePath = (value) => value.split(path3.sep).join("/");
-var digestBytes = (value) => `sha256:${createHash3("sha256").update(value).digest("hex")}`;
+var digestBytes = (value) => `sha256:${createHash4("sha256").update(value).digest("hex")}`;
 var truncate = (value, maxLength = MAX_TOOL_OUTPUT) => value.length <= maxLength ? value : `${value.slice(0, maxLength)}
 \u2026 output truncated (${value.length - maxLength} characters omitted)`;
 var cursorEncode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
@@ -2173,7 +2376,7 @@ var createHarnessMcpTools = async (configuration, options = {}) => {
 var mcpConfigurationFingerprintInput = (configuration) => serializeJsonValue(configuration);
 
 // src/orchestration.ts
-import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
 import {
   applySafetyPolicyToAgent,
   createBudgetGuard,
@@ -2220,7 +2423,7 @@ var childHarnessBinding = (parent, profile, model, toolNames, config) => ({
   schemaVersion: 1,
   id: `${parent.id}-${profile}`,
   version: parent.version,
-  fingerprint: `sha256:${createHash4("sha256").update(JSON.stringify({
+  fingerprint: `sha256:${createHash5("sha256").update(JSON.stringify({
     parent: parent.fingerprint,
     profile,
     model: {
@@ -2344,7 +2547,7 @@ var runHarnessReviewGroup = async (runtime, input, profiles = ["explorer", "revi
 };
 
 // src/execution-environment.ts
-import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID3 } from "crypto";
 import {
   chmod as chmod2,
   lstat as lstat5,
@@ -2384,8 +2587,8 @@ var BUILT_IN_TOOL_NAMES = new Set([
   "apply_environment_patch",
   "environment_status"
 ]);
-var digest2 = (value) => `sha256:${createHash5("sha256").update(value).digest("hex")}`;
-var runHash = (runId) => createHash5("sha256").update(runId).digest("hex").slice(0, 24);
+var digest2 = (value) => `sha256:${createHash6("sha256").update(value).digest("hex")}`;
+var runHash = (runId) => createHash6("sha256").update(runId).digest("hex").slice(0, 24);
 var isInside3 = (root, candidate) => {
   const relative = path7.relative(root, candidate);
   return relative === "" || relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
@@ -3357,11 +3560,11 @@ var describeOciCommand = (command, args) => commandDisplay([command, ...args]);
 // src/harness.ts
 var APPROVAL_VERSION = "2026-08-17-v5";
 var TOOL_CONTRACT_VERSION = "enforced-execution-v1";
-var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, executionEnvironment) => ({
+var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, providerTransportFingerprint, executionEnvironment) => ({
   schemaVersion: 1,
   id: "zhivex-harness",
   version: HARNESS_VERSION,
-  fingerprint: `sha256:${createHash6("sha256").update(JSON.stringify({
+  fingerprint: `sha256:${createHash7("sha256").update(JSON.stringify({
     configSchemaVersion: HARNESS_CONFIG_SCHEMA_VERSION,
     approvalVersion: APPROVAL_VERSION,
     toolContractVersion: TOOL_CONTRACT_VERSION,
@@ -3369,6 +3572,7 @@ var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, exe
     provider: config.provider,
     model: config.model,
     runtimeModel: inspectHarnessModelCapabilities(model),
+    providerTransportFingerprint,
     subagentModels: Object.fromEntries(config.orchestration.profiles.map((profile) => [
       profile,
       inspectHarnessModelCapabilities(subagentModels?.[profile] ?? model)
@@ -3591,32 +3795,49 @@ var createExecutionEnvironmentTools = (workspace) => ({
   })
 });
 var estimateMessageTokens = (messages) => Math.max(1, Math.ceil(JSON.stringify(messages).length / 4));
-var createHarnessCompactor = () => {
+var summarizeHarnessMessages = (messages) => {
   const redaction = createRedactionPolicy2({ includeEmails: true });
-  return async ({ messages }) => {
-    const summaries = messages.map((message, index) => {
-      const record = message;
-      const parts = (record.parts ?? []).map((part) => {
-        if (part.type === "text" && typeof part.text === "string") {
-          const text = redaction.redactText(part.text).replace(/\s+/g, " ").trim();
-          return text.length > 160 ? `${text.slice(0, 160)}\u2026` : text;
-        }
-        if (part.type === "tool-call") {
-          const call = part.toolCall;
-          return `tool-call:${typeof call?.name === "string" ? call.name : "unknown"}`;
-        }
-        if (part.type === "tool-result") {
-          const result = part.toolResult;
-          return `tool-result:${typeof result?.toolName === "string" ? result.toolName : "unknown"}`;
-        }
-        return typeof part.type === "string" ? part.type : "part";
-      });
-      return `${index + 1}. ${record.role ?? "message"}: ${parts.join(" | ")}`;
+  const summaries = messages.map((message, index) => {
+    const record = message;
+    const parts = (record.parts ?? []).map((part) => {
+      if (part.type === "text" && typeof part.text === "string") {
+        const text = redaction.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]").replace(/\s+/g, " ").trim();
+        return text.length > 160 ? `${text.slice(0, 160)}\u2026` : text;
+      }
+      if (part.type === "tool-call") {
+        const call = part.toolCall;
+        return `tool-call:${typeof call?.name === "string" ? call.name : "unknown"}`;
+      }
+      if (part.type === "tool-result") {
+        const result = part.toolResult;
+        return `tool-result:${typeof result?.toolName === "string" ? result.toolName : "unknown"}`;
+      }
+      return typeof part.type === "string" ? part.type : "part";
     });
-    const summary = summaries.join(`
+    return `${index + 1}. ${record.role ?? "message"}: ${parts.join(" | ")}`;
+  });
+  const summary = summaries.join(`
 `);
+  return summary.length > 4000 ? `${summary.slice(0, 4000)}\u2026` : summary;
+};
+var compactHarnessMessages = (messages) => {
+  if (messages.length === 0)
+    return [];
+  return [
+    {
+      role: "user",
+      parts: [{
+        type: "text",
+        text: `[Compacted conversation context]
+${summarizeHarnessMessages(messages)}`
+      }]
+    }
+  ];
+};
+var createHarnessCompactor = () => {
+  return async ({ messages }) => {
     return {
-      summary: summary.length > 4000 ? `${summary.slice(0, 4000)}\u2026` : summary,
+      summary: summarizeHarnessMessages(messages),
       metadata: {
         strategy: "deterministic-redacted-transcript",
         sourceMessages: messages.length
@@ -3679,7 +3900,7 @@ var createProviderCompatibleBudget = (config) => {
   };
 };
 var createHarness = async (options = {}) => {
-  const config = resolveHarnessConfig(options);
+  const config = resolveHarnessConfig(options, options.providerRegistry);
   const workspace = await Workspace.open(config.workspace);
   await validateStateDirectory(config.workspace, config.stateDirectory);
   const executionEnvironment = config.execution.backend === "oci" ? await createHarnessOciExecutionEnvironment({
@@ -3688,7 +3909,7 @@ var createHarness = async (options = {}) => {
     stateDirectory: config.stateDirectory,
     ...options.ociRuntimeAdapter ? { runtime: options.ociRuntimeAdapter } : {}
   }) : undefined;
-  const model = options.modelInstance ?? createProviderModel(config, options.env ?? process.env);
+  const model = options.modelInstance ?? createProviderModel(config, options.env ?? process.env, options.providerRegistry);
   const capabilityRequirements = [...new Set([
     ...config.requiredCapabilities,
     ...config.orchestration.profiles.length > 0 || config.mcpConfigPath || options.mcpConfiguration ? ["tools", "streaming"] : []
@@ -3730,7 +3951,7 @@ var createHarness = async (options = {}) => {
     await options.onTelemetryEvent?.(event);
   };
   const costGuardrails = createCostGuardrails(config);
-  const binding = createHarnessBinding(config, mcpConfiguration, model, options.subagentModels, executionEnvironment);
+  const binding = createHarnessBinding(config, mcpConfiguration, model, options.subagentModels, (options.providerRegistry ?? DEFAULT_PROVIDER_REGISTRY).transportFingerprint(options.env ?? process.env), executionEnvironment);
   const subagentRuntime = createHarnessSubagents({
     config,
     parentBinding: binding,
@@ -3862,33 +4083,851 @@ var appendUserMessage = (messages, text) => [
 import {
   estimateAgentRunCost
 } from "@zhivex-ai/agents/ops";
-var CLI_JSON_SCHEMA_VERSION = 1;
-var HARNESS_RESUME_METADATA_KEY = "zhivexHarnessResume";
-var HARNESS_RESUME_METADATA_SCHEMA_VERSION = 1;
-var CLI_EXIT_CODES = {
-  success: 0,
-  runtimeError: 1,
-  usageError: 2,
-  doctorFailed: 3
-};
-var COMMANDS = new Set(["run", "review", "chat", "providers", "doctor", "resume", "runs", "help", "version"]);
-var RUNS_COMMANDS = new Set(["list", "inspect", "cancel", "cleanup", "export"]);
-var RUN_STATUSES = new Set([
-  "queued",
-  "running",
-  "completed",
-  "suspended",
-  "waiting_approval",
-  "cancel_requested",
-  "failed",
-  "cancelled",
-  "timed_out"
-]);
 
-class CliUsageError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CliUsageError";
+// src/routing.ts
+var routeError = (value) => new Error(`Invalid route: ${value}. Use <profile>=<provider>[:<model>].`);
+var parseHarnessModelRoute = (value, registry = DEFAULT_PROVIDER_REGISTRY) => {
+  const separator = value.indexOf("=");
+  if (separator <= 0 || separator === value.length - 1) {
+    throw routeError(value);
+  }
+  const profile = value.slice(0, separator).trim().toLowerCase();
+  if (!HARNESS_SUBAGENT_PROFILES.includes(profile)) {
+    throw routeError(value);
+  }
+  const target = value.slice(separator + 1).trim();
+  const modelSeparator = target.indexOf(":");
+  const providerInput = (modelSeparator === -1 ? target : target.slice(0, modelSeparator)).trim();
+  const provider = registry.parse(providerInput);
+  const configuredModel = modelSeparator === -1 ? "" : target.slice(modelSeparator + 1).trim();
+  if (modelSeparator !== -1 && !configuredModel) {
+    throw routeError(value);
+  }
+  const model = configuredModel || registry.descriptor(provider).defaultModel;
+  if (/[\u0000-\u001f\u007f]/.test(model) || model.length > 256) {
+    throw routeError(value);
+  }
+  return Object.freeze({
+    profile,
+    provider,
+    model
+  });
+};
+var resolveHarnessModelRoutes = (values = [], registry = DEFAULT_PROVIDER_REGISTRY) => {
+  const routes = new Map;
+  for (const value of values) {
+    const route = parseHarnessModelRoute(value, registry);
+    if (routes.has(route.profile)) {
+      throw new Error(`Duplicate model route for ${route.profile}.`);
+    }
+    routes.set(route.profile, route);
+  }
+  return routes;
+};
+var createHarnessRouteModels = (routes, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => Object.fromEntries([...routes].map(([profile, route]) => [
+  profile,
+  registry.createModel(route, env)
+]));
+var serializeHarnessModelRoutes = (routes) => Object.fromEntries([...routes].map(([profile, route]) => [
+  profile,
+  { provider: route.provider, model: route.model }
+]));
+
+// src/cli-stream.ts
+var CLI_JSON_SCHEMA_VERSION = 1;
+var CLI_EVENT_SCHEMA_VERSION = 1;
+var streamEventDocument = (event, sequence = 0) => {
+  if (!Number.isSafeInteger(sequence) || sequence < 0) {
+    throw new Error("JSONL event sequence must be a non-negative integer.");
+  }
+  const base = {
+    schemaVersion: CLI_EVENT_SCHEMA_VERSION,
+    kind: "run-event",
+    sequence,
+    type: event.type
+  };
+  switch (event.type) {
+    case "text-delta":
+      return { ...base, textDelta: event.textDelta };
+    case "tool-call":
+      return { ...base, toolCallId: event.toolCall.id, toolName: event.toolCall.name };
+    case "tool-result":
+      return {
+        ...base,
+        toolCallId: event.toolResult.toolCallId,
+        toolName: event.toolResult.toolName,
+        isError: event.toolResult.isError
+      };
+    case "tool-approval-request":
+    case "agent-approval-request":
+      return {
+        ...base,
+        approvalRequestId: event.approval.id,
+        approvalKind: event.approval.kind ?? "provider",
+        toolName: event.approval.name
+      };
+    case "agent-approval-resolved":
+      return {
+        ...base,
+        approvalRequestId: event.approval.approvalRequestId,
+        approved: event.approval.approve
+      };
+    case "provider-data":
+      return { ...base, provider: event.provider };
+    case "image-generation":
+      return {
+        ...base,
+        provider: event.provider,
+        partial: event.partial,
+        ...event.id ? { id: event.id } : {},
+        ...event.index !== undefined ? { index: event.index } : {}
+      };
+    case "finish":
+      return {
+        ...base,
+        ...event.finishReason ? { finishReason: event.finishReason } : {},
+        ...event.usage ? { usage: event.usage } : {}
+      };
+    case "error":
+      return { ...base, error: "Provider stream failed." };
+    case "agent-run-start":
+      return { ...base, currentStep: event.currentStep, maxSteps: event.maxSteps };
+    case "agent-step-start":
+      return { ...base, stepIndex: event.stepIndex };
+    case "agent-step-finish":
+      return {
+        ...base,
+        stepIndex: event.step.index,
+        status: event.step.status,
+        toolCalls: event.step.toolResults.length
+      };
+    case "agent-compaction":
+      return {
+        ...base,
+        compactionId: event.compaction.id,
+        reasons: event.compaction.reasons,
+        messageCountBefore: event.compaction.messageCountBefore,
+        messageCountAfter: event.compaction.messageCountAfter
+      };
+    case "agent-run-finish":
+      return {
+        ...base,
+        runId: event.state.runId,
+        status: event.status,
+        provider: event.state.provider,
+        model: event.state.modelId
+      };
+  }
+};
+var serializeStreamEvent = (event, sequence = 0) => JSON.stringify(streamEventDocument(event, sequence));
+var streamResultDocument = (result, sequence = 0) => {
+  if (!Number.isSafeInteger(sequence) || sequence < 0) {
+    throw new Error("JSONL result sequence must be a non-negative integer.");
+  }
+  return {
+    schemaVersion: CLI_EVENT_SCHEMA_VERSION,
+    kind: "run-result",
+    sequence,
+    runId: result.runId,
+    status: result.status,
+    provider: result.provider,
+    model: result.model,
+    steps: result.steps,
+    toolCalls: result.toolCalls,
+    pendingApprovals: (result.pendingApprovals ?? []).map((approval) => ({
+      id: approval.id,
+      kind: approval.kind,
+      name: approval.name,
+      ...approval.childRunId ? { childRunId: approval.childRunId } : {},
+      ...approval.childAgentId ? { childAgentId: approval.childAgentId } : {}
+    })),
+    children: (result.children ?? []).map((child) => ({
+      runId: child.runId,
+      status: child.status
+    }))
+  };
+};
+var serializeStreamResult = (result, sequence = 0) => JSON.stringify(streamResultDocument(result, sequence));
+
+// src/sessions.ts
+import { createHash as createHash8, randomUUID as randomUUID4 } from "crypto";
+import { chmod as chmod3, lstat as lstat6, mkdir as mkdir4, open as open3, realpath as realpath4, stat as stat3 } from "fs/promises";
+import path8 from "path";
+import { createRedactionPolicy as createRedactionPolicy3 } from "@zhivex-ai/agents";
+import { Database as Database2 } from "bun:sqlite";
+var HARNESS_SESSION_INDEX_FILE = "operations.sqlite";
+var HARNESS_SESSION_SCHEMA_VERSION = 1;
+var SESSION_RUN_STATUSES = [
+  "created",
+  "running",
+  "waiting_approval",
+  "cancel_requested",
+  "completed",
+  "failed",
+  "cancelled",
+  "timed_out"
+];
+var TERMINAL_SESSION_RUN_STATUSES = [
+  "completed",
+  "failed",
+  "cancelled",
+  "timed_out"
+];
+var DEFAULT_RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
+var DEFAULT_MAX_SESSIONS = 200;
+var DEFAULT_MAX_RUNS = 1000;
+var DEFAULT_MAX_METADATA_BYTES = 4096;
+var DEFAULT_MAX_INDEX_BYTES = 16 * 1024 * 1024;
+var MAX_LIST_LIMIT = 200;
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/+\-]{0,255}$/;
+var TERMINAL_STATUSES2 = new Set(TERMINAL_SESSION_RUN_STATUSES);
+var ACTIVE_STATUSES = new Set([
+  "created",
+  "running",
+  "waiting_approval",
+  "cancel_requested"
+]);
+var STATUS_TRANSITIONS = {
+  created: new Set(["created", "running", "waiting_approval", "completed", "failed", "cancelled", "timed_out"]),
+  running: new Set(["running", "waiting_approval", "cancel_requested", "completed", "failed", "cancelled", "timed_out"]),
+  waiting_approval: new Set(["waiting_approval", "running", "cancel_requested", "completed", "failed", "cancelled", "timed_out"]),
+  cancel_requested: new Set(["cancel_requested", "cancelled", "failed", "timed_out"]),
+  completed: new Set(["completed"]),
+  failed: new Set(["failed"]),
+  cancelled: new Set(["cancelled"]),
+  timed_out: new Set(["timed_out"])
+};
+var metadataRedaction = createRedactionPolicy3({
+  includeEmails: true,
+  rules: [
+    { name: "private-key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
+    { name: "common-provider-key", pattern: /\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]{8,}\b/gi },
+    { name: "url-credentials", pattern: /:\/\/[^\s/@:]+:[^\s/@]+@/g, replacement: "://[REDACTED]@" }
+  ]
+});
+var byteLength = (value) => Buffer.byteLength(value, "utf8");
+var boundedInteger = (name, value, fallback, minimum) => {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < minimum) {
+    throw new Error(`${name} must be an integer greater than or equal to ${minimum}.`);
+  }
+  return resolved;
+};
+var assertTimestamp = (name, value) => {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative integer timestamp.`);
+  }
+};
+var assertIdentifier = (name, value) => {
+  if (!ID_PATTERN.test(value)) {
+    throw new Error(`${name} contains unsupported characters or exceeds 256 bytes.`);
+  }
+  if (metadataRedaction.redactText(value) !== value) {
+    throw new Error(`${name} resembles sensitive metadata and cannot be stored in the session index.`);
+  }
+  return value;
+};
+var assertScopeSegment = (name, value) => {
+  const normalized = value.trim();
+  if (!normalized || normalized.length > 128 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new Error(`${name} must contain 1-128 printable characters.`);
+  }
+  return normalized;
+};
+var normalizeTitle = (value, maxMetadataBytes) => {
+  if (value === undefined || value === null) {
+    return value;
+  }
+  const normalized = metadataRedaction.redactText(value).replace(/[\u0000-\u001f\u007f]+/g, " ").trim();
+  if (!normalized) {
+    throw new Error("Session title must not be empty.");
+  }
+  if (byteLength(normalized) > maxMetadataBytes) {
+    throw new Error(`Session title exceeds the ${maxMetadataBytes}-byte metadata limit.`);
+  }
+  return normalized;
+};
+var normalizeScope = (scope) => {
+  const tenantId = assertScopeSegment("scope.tenantId", scope.tenantId);
+  const userId = scope.userId === undefined ? "" : assertScopeSegment("scope.userId", scope.userId);
+  const namespace = scope.namespace === undefined ? "" : assertScopeSegment("scope.namespace", scope.namespace);
+  return `${tenantId}\x00${userId}\x00${namespace}`;
+};
+var stableKey = (kind, value) => createHash8("sha256").update(kind).update("\x00").update(value).digest("hex");
+var sessionId = () => `ses_${randomUUID4()}`;
+var turnId = () => `turn_${randomUUID4()}`;
+var isMissing = (error) => error.code === "ENOENT";
+var ensurePrivateDatabase = async (workspace, stateDirectory) => {
+  const requestedStateDirectory = path8.resolve(stateDirectory);
+  await validateStateDirectory(workspace, requestedStateDirectory);
+  await mkdir4(requestedStateDirectory, { recursive: true, mode: 448 });
+  const directoryEntry = await lstat6(requestedStateDirectory);
+  if (directoryEntry.isSymbolicLink() || !directoryEntry.isDirectory()) {
+    throw new Error(`The session state directory must be a real directory: ${requestedStateDirectory}.`);
+  }
+  await chmod3(requestedStateDirectory, 448);
+  const canonicalStateDirectory2 = await realpath4(requestedStateDirectory);
+  const databasePath = path8.join(canonicalStateDirectory2, HARNESS_SESSION_INDEX_FILE);
+  let databaseEntry;
+  try {
+    databaseEntry = await lstat6(databasePath);
+  } catch (error) {
+    if (!isMissing(error)) {
+      throw error;
+    }
+    try {
+      const handle = await open3(databasePath, "wx", 384);
+      await handle.close();
+    } catch (creationError) {
+      if (creationError.code !== "EEXIST") {
+        throw creationError;
+      }
+    }
+    databaseEntry = await lstat6(databasePath);
+  }
+  if (databaseEntry.isSymbolicLink() || !databaseEntry.isFile()) {
+    throw new Error(`The session SQLite path must be a real file: ${databasePath}.`);
+  }
+  await chmod3(databasePath, 384);
+  return { databasePath, databaseEntry };
+};
+var toRunReference = (row) => ({
+  turnId: row.turn_id,
+  ...row.source_turn_id ? { sourceTurnId: row.source_turn_id } : {},
+  sequence: row.ordinal,
+  runId: row.run_id,
+  provider: row.provider,
+  model: row.model,
+  ...row.role ? { role: row.role } : {},
+  status: row.status,
+  createdAt: row.created_at,
+  updatedAt: row.updated_at,
+  ...row.completed_at === null ? {} : { completedAt: row.completed_at }
+});
+var metadataSize = (input) => Object.values(input).reduce((total, value) => total + (typeof value === "string" ? byteLength(value) : 0), 0);
+var isTerminal = (status) => TERMINAL_STATUSES2.has(status);
+var openCliSessionStore = async (options) => {
+  const workspace = await realpath4(path8.resolve(options.workspace));
+  const workspaceEntry = await stat3(workspace);
+  if (!workspaceEntry.isDirectory()) {
+    throw new Error(`The session workspace is not a directory: ${workspace}.`);
+  }
+  const scopeValue2 = normalizeScope(options.scope);
+  const workspaceKey = stableKey("workspace", workspace);
+  const scopeKey = stableKey("scope", scopeValue2);
+  const retentionMs = boundedInteger("retentionMs", options.retentionMs, DEFAULT_RETENTION_MS, 0);
+  const maxSessions = boundedInteger("maxSessionsPerWorkspace", options.maxSessionsPerWorkspace, DEFAULT_MAX_SESSIONS, 1);
+  const maxRuns = boundedInteger("maxRunsPerSession", options.maxRunsPerSession, DEFAULT_MAX_RUNS, 1);
+  const maxMetadataBytes = boundedInteger("maxMetadataBytes", options.maxMetadataBytes, DEFAULT_MAX_METADATA_BYTES, 32);
+  const maxIndexBytes = boundedInteger("maxIndexBytes", options.maxIndexBytes, DEFAULT_MAX_INDEX_BYTES, 1024);
+  const now = options.now ?? Date.now;
+  const { databasePath, databaseEntry } = await ensurePrivateDatabase(workspace, options.stateDirectory);
+  const database = new Database2(databasePath, { create: false, strict: true });
+  let closed = false;
+  const assertOpen = () => {
+    if (closed) {
+      throw new Error("The CLI session store is closed.");
+    }
+  };
+  const transaction = (operation) => {
+    assertOpen();
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      const result = operation();
+      const size = database.query(`
+        SELECT
+          COALESCE((SELECT SUM(metadata_bytes) FROM zhivex_cli_sessions WHERE workspace_key = ?1 AND scope_key = ?2), 0) +
+          COALESCE((SELECT SUM(r.metadata_bytes) FROM zhivex_cli_session_runs r JOIN zhivex_cli_sessions s ON s.session_id = r.session_id WHERE s.workspace_key = ?1 AND s.scope_key = ?2), 0)
+          AS size
+      `).get(workspaceKey, scopeKey)?.size ?? 0;
+      if (size > maxIndexBytes) {
+        throw new Error(`Session index metadata exceeds the ${maxIndexBytes}-byte limit.`);
+      }
+      database.exec("COMMIT");
+      return result;
+    } catch (error) {
+      try {
+        database.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  };
+  const ensureRevision = (row, expected) => {
+    if (expected !== undefined && row.revision !== expected) {
+      throw new Error(`Session ${row.session_id} changed concurrently (expected revision ${expected}, found ${row.revision}).`);
+    }
+  };
+  const selectSessionRow = (candidateSessionId, includeDeleted = false) => {
+    assertIdentifier("sessionId", candidateSessionId);
+    return database.query(`
+      SELECT session_id, title, parent_session_id, forked_from_turn_id, revision, activity_seq,
+             created_at, updated_at, archived_at, deleted_at
+      FROM zhivex_cli_sessions
+      WHERE session_id = ?1 AND workspace_key = ?2 AND scope_key = ?3
+      ${includeDeleted ? "" : "AND deleted_at IS NULL"}
+    `).get(candidateSessionId, workspaceKey, scopeKey);
+  };
+  const requireSessionRow = (candidateSessionId, includeDeleted = false) => {
+    const row = selectSessionRow(candidateSessionId, includeDeleted);
+    if (!row) {
+      throw new Error(`Session ${candidateSessionId} was not found in this workspace and scope.`);
+    }
+    return row;
+  };
+  const selectRuns = (candidateSessionId) => database.query(`
+    SELECT turn_id, source_turn_id, ordinal, run_id, provider, model, role, status,
+           created_at, updated_at, completed_at
+    FROM zhivex_cli_session_runs
+    WHERE session_id = ?1
+    ORDER BY ordinal ASC
+  `).all(candidateSessionId).map(toRunReference);
+  const nextActivitySequence = () => database.query(`
+    SELECT COALESCE(MAX(activity_seq), 0) + 1 AS count
+    FROM zhivex_cli_sessions
+    WHERE workspace_key = ?1 AND scope_key = ?2
+  `).get(workspaceKey, scopeKey)?.count ?? 1;
+  const sessionBase = (row) => ({
+    schemaVersion: HARNESS_SESSION_SCHEMA_VERSION,
+    sessionId: row.session_id,
+    workspaceKey,
+    scopeKey,
+    ...row.title ? { title: row.title } : {},
+    ...row.parent_session_id ? { parentSessionId: row.parent_session_id } : {},
+    ...row.forked_from_turn_id ? { forkedFromTurnId: row.forked_from_turn_id } : {},
+    revision: row.revision,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    ...row.archived_at === null ? {} : { archivedAt: row.archived_at },
+    ...row.deleted_at === null ? {} : { deletedAt: row.deleted_at }
+  });
+  const hydrate = (row) => ({
+    ...sessionBase(row),
+    runs: selectRuns(row.session_id)
+  });
+  const latestRunRow = (candidateSessionId) => database.query(`
+    SELECT turn_id, source_turn_id, ordinal, run_id, provider, model, role, status,
+           created_at, updated_at, completed_at
+    FROM zhivex_cli_session_runs
+    WHERE session_id = ?1
+    ORDER BY ordinal DESC
+    LIMIT 1
+  `).get(candidateSessionId);
+  const assertNoActiveRun = (candidateSessionId, action) => {
+    const latest = latestRunRow(candidateSessionId);
+    if (latest && ACTIVE_STATUSES.has(latest.status)) {
+      throw new Error(`Cannot ${action} session ${candidateSessionId} while run ${latest.run_id} is ${latest.status}.`);
+    }
+  };
+  const insertRun = (candidateSessionId, input, sequence, sourceTurnId) => {
+    const runId = assertIdentifier("runId", input.runId);
+    const provider = assertIdentifier("provider", input.provider);
+    const model = assertIdentifier("model", input.model);
+    const role = input.role === undefined ? null : assertIdentifier("role", input.role);
+    const status = input.status ?? "created";
+    if (!SESSION_RUN_STATUSES.includes(status)) {
+      throw new Error(`Unsupported session run status: ${String(status)}.`);
+    }
+    const createdAt = input.createdAt ?? now();
+    assertTimestamp("createdAt", createdAt);
+    const entryBytes = metadataSize({ runId, provider, model, role });
+    if (entryBytes > maxMetadataBytes) {
+      throw new Error(`Run reference metadata exceeds the ${maxMetadataBytes}-byte limit.`);
+    }
+    const candidateTurnId = turnId();
+    database.query(`
+      INSERT INTO zhivex_cli_session_runs (
+        turn_id, source_turn_id, session_id, ordinal, run_id, provider, model, role,
+        status, created_at, updated_at, completed_at, metadata_bytes
+      ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?10, ?11, ?12)
+    `).run(candidateTurnId, sourceTurnId ?? null, candidateSessionId, sequence, runId, provider, model, role, status, createdAt, isTerminal(status) ? createdAt : null, entryBytes);
+  };
+  try {
+    const openedEntry = await lstat6(databasePath);
+    if (openedEntry.isSymbolicLink() || !openedEntry.isFile() || openedEntry.dev !== databaseEntry.dev || openedEntry.ino !== databaseEntry.ino) {
+      throw new Error(`The session SQLite path changed while it was being opened: ${databasePath}.`);
+    }
+    database.exec("PRAGMA journal_mode = WAL");
+    database.exec("PRAGMA busy_timeout = 5000");
+    database.exec("PRAGMA foreign_keys = ON");
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS zhivex_cli_session_schema (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+        version INTEGER NOT NULL
+      );
+      INSERT OR IGNORE INTO zhivex_cli_session_schema (singleton, version)
+      VALUES (1, ${HARNESS_SESSION_SCHEMA_VERSION});
+      CREATE TABLE IF NOT EXISTS zhivex_cli_sessions (
+        session_id TEXT PRIMARY KEY,
+        workspace_key TEXT NOT NULL,
+        scope_key TEXT NOT NULL,
+        title TEXT,
+        parent_session_id TEXT,
+        forked_from_turn_id TEXT,
+        revision INTEGER NOT NULL DEFAULT 0,
+        activity_seq INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        archived_at INTEGER,
+        deleted_at INTEGER,
+        metadata_bytes INTEGER NOT NULL,
+        CHECK (length(session_id) <= 260),
+        CHECK (metadata_bytes >= 0)
+      );
+      CREATE INDEX IF NOT EXISTS zhivex_cli_sessions_latest
+        ON zhivex_cli_sessions (workspace_key, scope_key, deleted_at, archived_at, activity_seq DESC);
+      CREATE TABLE IF NOT EXISTS zhivex_cli_session_runs (
+        turn_id TEXT PRIMARY KEY,
+        source_turn_id TEXT,
+        session_id TEXT NOT NULL REFERENCES zhivex_cli_sessions(session_id) ON DELETE CASCADE,
+        ordinal INTEGER NOT NULL,
+        run_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        role TEXT,
+        status TEXT NOT NULL CHECK (status IN ('created', 'running', 'waiting_approval', 'cancel_requested', 'completed', 'failed', 'cancelled', 'timed_out')),
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        metadata_bytes INTEGER NOT NULL,
+        UNIQUE (session_id, ordinal),
+        UNIQUE (session_id, run_id),
+        CHECK (ordinal >= 0),
+        CHECK (metadata_bytes >= 0)
+      );
+      CREATE INDEX IF NOT EXISTS zhivex_cli_session_runs_latest
+        ON zhivex_cli_session_runs (session_id, ordinal DESC);
+    `);
+    const schemaVersion = database.query("SELECT version FROM zhivex_cli_session_schema WHERE singleton = 1").get()?.version;
+    if (schemaVersion !== HARNESS_SESSION_SCHEMA_VERSION) {
+      throw new Error(`Unsupported CLI session schema version: ${String(schemaVersion)}.`);
+    }
+    await chmod3(databasePath, 384);
+  } catch (error) {
+    database.close(false);
+    throw error;
+  }
+  const prune = async (input = {}) => transaction(() => {
+    const before = input.before ?? Math.max(0, now() - retentionMs);
+    assertTimestamp("before", before);
+    const deletedSessions = database.query(`
+      SELECT COUNT(*) AS count FROM zhivex_cli_sessions
+      WHERE workspace_key = ?1 AND scope_key = ?2
+        AND updated_at < ?3
+        AND (archived_at IS NOT NULL OR deleted_at IS NOT NULL)
+    `).get(workspaceKey, scopeKey, before)?.count ?? 0;
+    database.query(`
+      DELETE FROM zhivex_cli_sessions
+      WHERE workspace_key = ?1 AND scope_key = ?2
+        AND updated_at < ?3
+        AND (archived_at IS NOT NULL OR deleted_at IS NOT NULL)
+    `).run(workspaceKey, scopeKey, before);
+    return { before, deletedSessions };
+  });
+  const store = {
+    databasePath,
+    workspaceKey,
+    scopeKey,
+    async create(input = {}) {
+      return transaction(() => {
+        const cutoff = Math.max(0, now() - retentionMs);
+        database.query(`
+          DELETE FROM zhivex_cli_sessions
+          WHERE workspace_key = ?1 AND scope_key = ?2 AND updated_at < ?3
+            AND (archived_at IS NOT NULL OR deleted_at IS NOT NULL)
+        `).run(workspaceKey, scopeKey, cutoff);
+        const count = database.query(`
+          SELECT COUNT(*) AS count FROM zhivex_cli_sessions
+          WHERE workspace_key = ?1 AND scope_key = ?2
+        `).get(workspaceKey, scopeKey)?.count ?? 0;
+        if (count >= maxSessions) {
+          throw new Error(`Session limit reached for this workspace and scope (${maxSessions}). Archive and prune an older session.`);
+        }
+        const createdAt = now();
+        assertTimestamp("now", createdAt);
+        const title = normalizeTitle(input.title, maxMetadataBytes) ?? null;
+        const candidateSessionId = sessionId();
+        const activitySequence = nextActivitySequence();
+        database.query(`
+          INSERT INTO zhivex_cli_sessions (
+            session_id, workspace_key, scope_key, title, revision, created_at,
+            updated_at, activity_seq, metadata_bytes
+          ) VALUES (?1, ?2, ?3, ?4, 0, ?5, ?5, ?6, ?7)
+        `).run(candidateSessionId, workspaceKey, scopeKey, title, createdAt, activitySequence, metadataSize({ title }));
+        if (input.initialRun) {
+          insertRun(candidateSessionId, input.initialRun, 0);
+        }
+        return hydrate(requireSessionRow(candidateSessionId));
+      });
+    },
+    async get(candidateSessionId, input = {}) {
+      assertOpen();
+      const row = selectSessionRow(candidateSessionId, input.includeDeleted ?? false);
+      return row ? hydrate(row) : undefined;
+    },
+    async list(query = {}) {
+      assertOpen();
+      const limit = boundedInteger("limit", query.limit, 50, 1);
+      if (limit > MAX_LIST_LIMIT) {
+        throw new Error(`limit cannot exceed ${MAX_LIST_LIMIT}.`);
+      }
+      const rows = database.query(`
+        SELECT session_id, title, parent_session_id, forked_from_turn_id, revision, activity_seq,
+               created_at, updated_at, archived_at, deleted_at
+        FROM zhivex_cli_sessions
+        WHERE workspace_key = ?1 AND scope_key = ?2
+          ${query.includeArchived ? "" : "AND archived_at IS NULL"}
+          ${query.includeDeleted ? "" : "AND deleted_at IS NULL"}
+        ORDER BY activity_seq DESC
+        LIMIT ?3
+      `).all(workspaceKey, scopeKey, limit);
+      return rows.map((row) => {
+        const latest = latestRunRow(row.session_id);
+        const runCount = database.query("SELECT COUNT(*) AS count FROM zhivex_cli_session_runs WHERE session_id = ?1").get(row.session_id)?.count ?? 0;
+        return {
+          ...sessionBase(row),
+          runCount,
+          ...latest ? { latestRun: toRunReference(latest) } : {}
+        };
+      });
+    },
+    async latest(input = {}) {
+      assertOpen();
+      const row = database.query(`
+        SELECT session_id, title, parent_session_id, forked_from_turn_id, revision, activity_seq,
+               created_at, updated_at, archived_at, deleted_at
+        FROM zhivex_cli_sessions
+        WHERE workspace_key = ?1 AND scope_key = ?2 AND deleted_at IS NULL
+          ${input.includeArchived ? "" : "AND archived_at IS NULL"}
+        ORDER BY activity_seq DESC
+        LIMIT 1
+      `).get(workspaceKey, scopeKey);
+      return row ? hydrate(row) : undefined;
+    },
+    async update(candidateSessionId, input) {
+      return transaction(() => {
+        const row = requireSessionRow(candidateSessionId);
+        ensureRevision(row, input.expectedRevision);
+        if (input.archived === true) {
+          assertNoActiveRun(candidateSessionId, "archive");
+        }
+        const title = input.title === undefined ? row.title : normalizeTitle(input.title, maxMetadataBytes) ?? null;
+        const updatedAt = now();
+        assertTimestamp("now", updatedAt);
+        const archivedAt = input.archived === undefined ? row.archived_at : input.archived ? updatedAt : null;
+        const activitySequence = nextActivitySequence();
+        database.query(`
+          UPDATE zhivex_cli_sessions
+          SET title = ?1, archived_at = ?2, updated_at = ?3, revision = revision + 1,
+              metadata_bytes = ?4, activity_seq = ?5
+          WHERE session_id = ?6 AND workspace_key = ?7 AND scope_key = ?8 AND revision = ?9
+        `).run(title, archivedAt, updatedAt, metadataSize({ title }), activitySequence, candidateSessionId, workspaceKey, scopeKey, row.revision);
+        return hydrate(requireSessionRow(candidateSessionId));
+      });
+    },
+    async rename(candidateSessionId, title, input = {}) {
+      return store.update(candidateSessionId, {
+        title,
+        ...input.expectedRevision === undefined ? {} : { expectedRevision: input.expectedRevision }
+      });
+    },
+    async appendRun(candidateSessionId, input, appendOptions = {}) {
+      return transaction(() => {
+        const row = requireSessionRow(candidateSessionId);
+        ensureRevision(row, appendOptions.expectedRevision);
+        if (row.archived_at !== null) {
+          throw new Error(`Cannot append a run to archived session ${candidateSessionId}.`);
+        }
+        const existing = database.query(`
+          SELECT turn_id, source_turn_id, ordinal, run_id, provider, model, role, status,
+                 created_at, updated_at, completed_at
+          FROM zhivex_cli_session_runs WHERE session_id = ?1 AND run_id = ?2
+        `).get(candidateSessionId, input.runId);
+        if (existing) {
+          const requestedStatus = input.status ?? "created";
+          if (existing.provider === input.provider && existing.model === input.model && (existing.role ?? undefined) === input.role && existing.status === requestedStatus) {
+            return hydrate(row);
+          }
+          throw new Error(`Run ${input.runId} is already immutably bound to ${existing.provider}/${existing.model} in this session.`);
+        }
+        assertNoActiveRun(candidateSessionId, "start another run in");
+        const count = database.query("SELECT COUNT(*) AS count FROM zhivex_cli_session_runs WHERE session_id = ?1").get(candidateSessionId)?.count ?? 0;
+        if (count >= maxRuns) {
+          throw new Error(`Run-reference limit reached for session ${candidateSessionId} (${maxRuns}).`);
+        }
+        insertRun(candidateSessionId, input, count);
+        const updatedAt = now();
+        assertTimestamp("now", updatedAt);
+        const activitySequence = nextActivitySequence();
+        database.query(`
+          UPDATE zhivex_cli_sessions SET updated_at = ?1, activity_seq = ?2, revision = revision + 1
+          WHERE session_id = ?3 AND revision = ?4
+        `).run(updatedAt, activitySequence, candidateSessionId, row.revision);
+        return hydrate(requireSessionRow(candidateSessionId));
+      });
+    },
+    async updateRun(candidateSessionId, runId, input) {
+      return transaction(() => {
+        const session = requireSessionRow(candidateSessionId);
+        ensureRevision(session, input.expectedSessionRevision);
+        assertIdentifier("runId", runId);
+        const run = database.query(`
+          SELECT turn_id, source_turn_id, ordinal, run_id, provider, model, role, status,
+                 created_at, updated_at, completed_at
+          FROM zhivex_cli_session_runs WHERE session_id = ?1 AND run_id = ?2
+        `).get(candidateSessionId, runId);
+        if (!run) {
+          throw new Error(`Run ${runId} is not linked to session ${candidateSessionId}.`);
+        }
+        if (!STATUS_TRANSITIONS[run.status].has(input.status)) {
+          throw new Error(`Run ${runId} cannot transition from ${run.status} to ${input.status}.`);
+        }
+        const updatedAt = input.updatedAt ?? now();
+        assertTimestamp("updatedAt", updatedAt);
+        if (updatedAt < run.updated_at) {
+          throw new Error(`Run ${runId} update timestamp cannot move backwards.`);
+        }
+        const completedAt = isTerminal(input.status) ? input.completedAt ?? updatedAt : null;
+        if (completedAt !== null) {
+          assertTimestamp("completedAt", completedAt);
+          if (completedAt < run.created_at || completedAt > updatedAt) {
+            throw new Error("completedAt must be between the run creation and update timestamps.");
+          }
+        }
+        database.query(`
+          UPDATE zhivex_cli_session_runs
+          SET status = ?1, updated_at = ?2, completed_at = ?3
+          WHERE session_id = ?4 AND run_id = ?5
+        `).run(input.status, updatedAt, completedAt, candidateSessionId, runId);
+        const activitySequence = nextActivitySequence();
+        database.query(`
+          UPDATE zhivex_cli_sessions SET updated_at = ?1, activity_seq = ?2, revision = revision + 1
+          WHERE session_id = ?3 AND revision = ?4
+        `).run(updatedAt, activitySequence, candidateSessionId, session.revision);
+        return hydrate(requireSessionRow(candidateSessionId));
+      });
+    },
+    async fork(candidateSessionId, input = {}) {
+      return transaction(() => {
+        const source = requireSessionRow(candidateSessionId);
+        ensureRevision(source, input.expectedRevision);
+        const sourceRuns = selectRuns(candidateSessionId);
+        let forkRuns = sourceRuns;
+        let forkedFromTurnId;
+        if (input.atTurnId) {
+          const index = sourceRuns.findIndex((run) => run.turnId === input.atTurnId);
+          if (index < 0) {
+            throw new Error(`Turn ${input.atTurnId} is not part of session ${candidateSessionId}.`);
+          }
+          forkRuns = sourceRuns.slice(0, index + 1);
+          forkedFromTurnId = input.atTurnId;
+        } else if (sourceRuns.length > 0) {
+          forkedFromTurnId = sourceRuns.at(-1).turnId;
+        }
+        const branchPoint = forkRuns.at(-1);
+        if (branchPoint && !isTerminal(branchPoint.status)) {
+          throw new Error(`Cannot fork from non-terminal run ${branchPoint.runId} (${branchPoint.status}).`);
+        }
+        if (forkRuns.length > maxRuns) {
+          throw new Error(`Fork history exceeds the ${maxRuns}-run limit.`);
+        }
+        const count = database.query(`
+          SELECT COUNT(*) AS count FROM zhivex_cli_sessions
+          WHERE workspace_key = ?1 AND scope_key = ?2
+        `).get(workspaceKey, scopeKey)?.count ?? 0;
+        if (count >= maxSessions) {
+          throw new Error(`Session limit reached for this workspace and scope (${maxSessions}).`);
+        }
+        const createdAt = now();
+        assertTimestamp("now", createdAt);
+        const title = normalizeTitle(input.title, maxMetadataBytes) ?? source.title;
+        const forkSessionId = sessionId();
+        const activitySequence = nextActivitySequence();
+        database.query(`
+          INSERT INTO zhivex_cli_sessions (
+            session_id, workspace_key, scope_key, title, parent_session_id,
+            forked_from_turn_id, revision, created_at, updated_at, activity_seq, metadata_bytes
+          ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, 0, ?7, ?7, ?8, ?9)
+        `).run(forkSessionId, workspaceKey, scopeKey, title, candidateSessionId, forkedFromTurnId ?? null, createdAt, activitySequence, metadataSize({ title }));
+        for (const [index, run] of forkRuns.entries()) {
+          insertRun(forkSessionId, {
+            runId: run.runId,
+            provider: run.provider,
+            model: run.model,
+            ...run.role ? { role: run.role } : {},
+            status: run.status,
+            createdAt: run.createdAt
+          }, index, run.turnId);
+          database.query(`
+            UPDATE zhivex_cli_session_runs
+            SET updated_at = ?1, completed_at = ?2
+            WHERE session_id = ?3 AND ordinal = ?4
+          `).run(run.updatedAt, run.completedAt ?? null, forkSessionId, index);
+        }
+        return hydrate(requireSessionRow(forkSessionId));
+      });
+    },
+    async archive(candidateSessionId, input = {}) {
+      return store.update(candidateSessionId, {
+        archived: true,
+        ...input.expectedRevision === undefined ? {} : { expectedRevision: input.expectedRevision }
+      });
+    },
+    async delete(candidateSessionId, input = {}) {
+      return transaction(() => {
+        const row = requireSessionRow(candidateSessionId);
+        ensureRevision(row, input.expectedRevision);
+        assertNoActiveRun(candidateSessionId, "delete");
+        const deletedAt = now();
+        assertTimestamp("now", deletedAt);
+        const activitySequence = nextActivitySequence();
+        database.query(`
+          UPDATE zhivex_cli_sessions
+          SET deleted_at = ?1, updated_at = ?1, activity_seq = ?2, revision = revision + 1
+          WHERE session_id = ?3 AND revision = ?4
+        `).run(deletedAt, activitySequence, candidateSessionId, row.revision);
+        return hydrate(requireSessionRow(candidateSessionId, true));
+      });
+    },
+    prune,
+    close() {
+      if (!closed) {
+        closed = true;
+        database.close(false);
+      }
+    }
+  };
+  return store;
+};
+var openSessionStore = openCliSessionStore;
+
+// src/cli.ts
+var HARNESS_RESUME_METADATA_KEY = "zhivexHarnessResume";
+var HARNESS_RESUME_METADATA_SCHEMA_VERSION = 1;
+var CLI_EXIT_CODES = {
+  success: 0,
+  runtimeError: 1,
+  usageError: 2,
+  doctorFailed: 3
+};
+var COMMANDS = new Set(["run", "review", "chat", "providers", "doctor", "resume", "runs", "sessions", "help", "version"]);
+var RUNS_COMMANDS = new Set(["list", "inspect", "cancel", "cleanup", "export"]);
+var SESSIONS_COMMANDS = new Set(["list", "inspect", "rename", "fork", "archive"]);
+var RUN_STATUSES = new Set([
+  "queued",
+  "running",
+  "completed",
+  "suspended",
+  "waiting_approval",
+  "cancel_requested",
+  "failed",
+  "cancelled",
+  "timed_out"
+]);
+
+class CliUsageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
   }
 }
 var harnessConfigInput = (config) => ({
@@ -3943,13 +4982,14 @@ var harnessConfigInput = (config) => ({
   } : {},
   ...config.mcpConfigPath ? { mcpConfigPath: config.mcpConfigPath } : {}
 });
-var createHarnessResumeMetadata = (config) => ({
+var createHarnessResumeMetadata = (config, routes) => ({
   [HARNESS_RESUME_METADATA_KEY]: JSON.parse(JSON.stringify({
     schemaVersion: HARNESS_RESUME_METADATA_SCHEMA_VERSION,
-    config
+    config,
+    ...routes && routes.size > 0 ? { routes: serializeHarnessModelRoutes(routes) } : {}
   }))
 });
-var readHarnessResumeConfig = (state) => {
+var readHarnessResumeDocument = (state) => {
   const value = state.metadata?.[HARNESS_RESUME_METADATA_KEY];
   if (value === undefined)
     return;
@@ -3960,12 +5000,39 @@ var readHarnessResumeConfig = (state) => {
   if (document.schemaVersion !== HARNESS_RESUME_METADATA_SCHEMA_VERSION || !document.config || typeof document.config !== "object" || Array.isArray(document.config)) {
     throw new Error("Persisted harness resume metadata is invalid.");
   }
+  return document;
+};
+var readHarnessResumeConfig = (state) => {
+  const document = readHarnessResumeDocument(state);
+  if (!document)
+    return;
   try {
     return harnessConfigInput(document.config);
   } catch {
     throw new Error("Persisted harness resume metadata is invalid.");
   }
 };
+var readHarnessResumeRoutes = (state) => {
+  const document = readHarnessResumeDocument(state);
+  if (!document?.routes)
+    return resolveHarnessModelRoutes();
+  if (typeof document.routes !== "object" || Array.isArray(document.routes)) {
+    throw new Error("Persisted harness routing metadata is invalid.");
+  }
+  try {
+    const values = Object.entries(document.routes).map(([profile, target]) => {
+      if (!target || typeof target !== "object" || Array.isArray(target))
+        throw new Error("invalid");
+      const route = target;
+      if (typeof route.provider !== "string" || typeof route.model !== "string")
+        throw new Error("invalid");
+      return `${profile}=${route.provider}:${route.model}`;
+    });
+    return resolveHarnessModelRoutes(values);
+  } catch {
+    throw new Error("Persisted harness routing metadata is invalid.");
+  }
+};
 var shellArgument = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
 var resumeCommand = (runId, config, approve = true) => [
   "zhivex-harness",
@@ -3994,7 +5061,16 @@ var parseCliArgs = (argv) => {
   let command = "run";
   let commandWasExplicit = false;
   const positional = [];
-  const options = { command, cascade: false, final: false, yes: false, json: false };
+  const options = {
+    command,
+    cascade: false,
+    final: false,
+    yes: false,
+    json: false,
+    jsonl: false,
+    continueSession: false,
+    implicitCommand: true
+  };
   let positionalOnly = false;
   for (let index = 0;index < argv.length; index += 1) {
     const argument = argv[index];
@@ -4028,6 +5104,21 @@ var parseCliArgs = (argv) => {
         options.model = optionValue(argv, index, argument);
         index += 1;
         break;
+      case "--route": {
+        const value = optionValue(argv, index, argument);
+        try {
+          parseHarnessModelRoute(value);
+        } catch (error) {
+          throw new CliUsageError(error instanceof Error ? error.message : String(error));
+        }
+        options.routes ??= [];
+        options.routes.push(value);
+        if (options.routes.length > HARNESS_SUBAGENT_PROFILES.length) {
+          throw new CliUsageError(`--route cannot be repeated more than ${HARNESS_SUBAGENT_PROFILES.length} times.`);
+        }
+        index += 1;
+        break;
+      }
       case "--workspace":
         options.workspace = optionValue(argv, index, argument);
         index += 1;
@@ -4251,6 +5342,16 @@ var parseCliArgs = (argv) => {
       case "--json":
         options.json = true;
         break;
+      case "--jsonl":
+        options.jsonl = true;
+        break;
+      case "--session":
+        options.sessionId = optionValue(argv, index, argument);
+        index += 1;
+        break;
+      case "--continue":
+        options.continueSession = true;
+        break;
       case "--status": {
         const value = optionValue(argv, index, argument);
         if (!RUN_STATUSES.has(value)) {
@@ -4312,6 +5413,16 @@ var parseCliArgs = (argv) => {
         positional.push(argument);
     }
   }
+  options.implicitCommand = !commandWasExplicit;
+  if (options.json && options.jsonl) {
+    throw new CliUsageError("You cannot combine --json and --jsonl.");
+  }
+  if (options.sessionId && options.continueSession) {
+    throw new CliUsageError("You cannot combine --session and --continue.");
+  }
+  if (options.jsonl && options.command !== "run" && options.command !== "resume") {
+    throw new CliUsageError("--jsonl is supported by run and resume.");
+  }
   if (options.command === "resume") {
     const runId = positional.shift();
     if (runId) {
@@ -4339,6 +5450,28 @@ var parseCliArgs = (argv) => {
     if (positional.length > 0) {
       throw new CliUsageError(`runs ${runsCommand} received unexpected positional arguments.`);
     }
+  } else if (options.command === "sessions") {
+    const sessionsCommand = positional.shift();
+    if (!sessionsCommand || !SESSIONS_COMMANDS.has(sessionsCommand)) {
+      throw new CliUsageError("sessions requires one of: list, inspect, rename, fork, archive.");
+    }
+    options.sessionsCommand = sessionsCommand;
+    if (sessionsCommand !== "list") {
+      const sessionId2 = positional.shift();
+      if (!sessionId2)
+        throw new CliUsageError(`sessions ${sessionsCommand} requires a sessionId.`);
+      options.sessionId = sessionId2;
+    }
+    if (sessionsCommand === "rename") {
+      const title = positional.join(" ").trim();
+      if (!title)
+        throw new CliUsageError("sessions rename requires a title.");
+      options.sessionTitle = title;
+      positional.length = 0;
+    }
+    if (positional.length > 0) {
+      throw new CliUsageError(`sessions ${sessionsCommand} received unexpected positional arguments.`);
+    }
   } else if (options.command === "run" || options.command === "review") {
     const prompt = positional.join(" ").trim();
     if (prompt) {
@@ -4352,21 +5485,24 @@ var parseCliArgs = (argv) => {
 var help = `Zhivex Harness v${HARNESS_VERSION}
 
 Usage:
-  zhivex-harness run [options] "task"
-  zhivex-harness review [options] "review task"
-  zhivex-harness chat [options]
-  zhivex-harness providers [--json]
-  zhivex-harness doctor [options] [--json]
-  zhivex-harness resume [options] <runId> --approve|--deny
-  zhivex-harness runs list [--status <status>] [--limit <n>] [--json]
-  zhivex-harness runs inspect <runId> [--json]
-  zhivex-harness runs cancel <runId> [--reason <text>] [--cascade] [--final]
-  zhivex-harness runs cleanup --before <date|timestamp> [--status <status>]
-  zhivex-harness runs export <runId> [--json]
+  zhx                              Start the interactive console
+  zhx run [options] "task"
+  zhx review [options] "review task"
+  zhx chat [options] [--continue|--session <id>]
+  zhx providers [--json]
+  zhx doctor [options] [--json]
+  zhx resume [options] <runId> --approve|--deny
+  zhx runs list [--status <status>] [--limit <n>] [--json]
+  zhx sessions list|inspect|rename|fork|archive
+
+The long command zhivex-harness remains supported for compatibility.
 
 Options:
-  --provider <meta|qwen|openai>  Provider (default: openai)
+  --provider <${PROVIDERS.join("|")}>  Provider (default: openai)
   --model <id>                   Override the default model
+  --route <role=provider[:model]> Route a subagent role; repeatable
+  --session <id>                 Open a durable interactive session
+  --continue                     Open the latest durable interactive session
   --workspace <path>             Target workspace (default: cwd)
   --state-dir <path>             Durable run-state directory
   --mcp-config <path>            Declarative governed MCP JSON configuration
@@ -4408,6 +5544,7 @@ Options:
   --max-parallel-reviews <1-4>   Review group concurrency ceiling (default: 2)
   --yes                          Automatically approve writes and checks
   --json                         Emit structured final output
+  --jsonl                        Stream redacted JSON Lines, then the final result
   -h, --help                     Show this help
   -v, --version                  Show the version
 
@@ -4420,7 +5557,8 @@ Exit codes:
 Credentials:
   OpenAI: OPENAI_API_KEY
   Meta:   MODEL_API_KEY
-  Qwen:   DASHSCOPE_API_KEY or QWEN_API_KEY`;
+  Qwen:   DASHSCOPE_API_KEY or QWEN_API_KEY
+  Gemini: GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY`;
 var summarizeApproval = (approval) => {
   const mustShowCompleteProposal = approval.name === "apply_patch";
   const argumentsText = !mustShowCompleteProposal && approval.arguments.length > 1200 ? `${approval.arguments.slice(0, 1200)}\u2026` : approval.arguments;
@@ -4524,16 +5662,23 @@ var runResultDocument = (result, harness) => ({
   },
   stateDirectory: harness.config.stateDirectory
 });
-var printTerminalResult = (result, harness, json, streamedText) => {
-  if (json) {
-    process.stdout.write(`${JSON.stringify(runResultDocument(result, harness), null, 2)}
+var printTerminalResult = (result, harness, output, tracker) => {
+  const document = runResultDocument(result, harness);
+  if (output.jsonl) {
+    tracker.sequence = (tracker.sequence ?? 0) + 1;
+    process.stdout.write(`${serializeStreamResult(document, tracker.sequence)}
 `);
     return;
   }
-  if (!streamedText && result.outputText) {
+  if (output.json) {
+    process.stdout.write(`${JSON.stringify(document, null, 2)}
+`);
+    return;
+  }
+  if (!tracker.streamedText && result.outputText) {
     process.stdout.write(result.outputText);
   }
-  if (result.outputText || streamedText) {
+  if (result.outputText || tracker.streamedText) {
     process.stdout.write(`
 `);
   }
@@ -4551,8 +5696,14 @@ ${summarizeApproval(approval)}
 `);
   }
 };
-var streamSink = (json, tracker) => async (event) => {
-  if (!json && event.type === "text-delta") {
+var streamSink = (output, tracker) => async (event) => {
+  if (output.jsonl) {
+    tracker.sequence = (tracker.sequence ?? 0) + 1;
+    process.stdout.write(`${serializeStreamEvent(event, tracker.sequence)}
+`);
+    return;
+  }
+  if (!output.json && event.type === "text-delta") {
     tracker.streamedText = true;
     process.stdout.write(event.textDelta);
   }
@@ -4570,23 +5721,57 @@ subagent finish \xB7 ${event.childRun.agentId ?? event.childRun.toolName} \xB7 $
 `);
   }
 };
+var resolvedRouting = (options) => {
+  return resolveHarnessModelRoutes(options.routes);
+};
+var assertRoutePricingIsSafe = (routes, costBudget) => {
+  if (routes.size > 0 && costBudget !== undefined) {
+    throw new CliUsageError("Cost budgets cannot be combined with model routes until pricing is configured per role.");
+  }
+};
+var withTemporaryHarnessProfiles = async (profiles, configure, operation) => {
+  await configure(profiles);
+  try {
+    return await operation();
+  } finally {
+    await configure([]);
+  }
+};
+var createConfiguredHarness = async (options, extraProfiles = [], persistedRoutes) => {
+  const routes = persistedRoutes ?? resolvedRouting(options);
+  const resolvedConfig = resolveHarnessConfig(options);
+  assertRoutePricingIsSafe(routes, resolvedConfig.costBudget);
+  const profiles = [...new Set([
+    ...options.subagentProfiles ?? [],
+    ...extraProfiles,
+    ...routes.keys()
+  ])];
+  const quietTelemetry = options.json || options.jsonl;
+  const harness = await createHarness({
+    ...options,
+    subagentProfiles: profiles,
+    subagentModels: createHarnessRouteModels(routes),
+    onTelemetryEvent: orchestrationObserver(quietTelemetry)
+  });
+  return { harness, routes };
+};
 var runOnce = async (options) => {
   if (!options.prompt) {
     throw new CliUsageError('Missing task. Example: zhivex-harness run "fix the tests".');
   }
-  const harness = await createHarness({ ...options, onTelemetryEvent: orchestrationObserver(options.json) });
+  const { harness, routes } = await createConfiguredHarness(options);
   try {
     const tracker = { streamedText: false };
     const result = await runHarness(harness, {
       prompt: options.prompt,
       scope: harness.config.scope,
-      metadata: createHarnessResumeMetadata(harness.config),
+      metadata: createHarnessResumeMetadata(harness.config, routes),
       ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
     }, {
-      onEvent: streamSink(options.json, tracker),
+      onEvent: streamSink(options, tracker),
       resolveApprovals: terminalApprovalResolver(options.yes)
     });
-    printTerminalResult(result, harness, options.json, tracker.streamedText);
+    printTerminalResult(result, harness, options, tracker);
     if (result.status === "failed" || result.status === "timed_out") {
       process.exitCode = CLI_EXIT_CODES.runtimeError;
     }
@@ -4603,11 +5788,7 @@ var reviewOnce = async (options) => {
     ...options.subagentProfiles ?? [],
     ...requestedReviewers
   ])];
-  const harness = await createHarness({
-    ...options,
-    subagentProfiles: enabledProfiles,
-    onTelemetryEvent: orchestrationObserver(options.json)
-  });
+  const { harness } = await createConfiguredHarness(options, enabledProfiles);
   try {
     const result = await runHarnessReviewGroup(harness, { prompt: options.prompt, scope: harness.config.scope }, requestedReviewers);
     const document = {
@@ -4678,22 +5859,31 @@ ${summarizeApproval(approval)}
 `);
     }
     const persistedResumeInput = readHarnessResumeConfig(state);
+    const persistedRoutes = readHarnessResumeRoutes(state);
     let persistedResumeOptions = {};
+    let resumeCostBudget = initialConfig.costBudget;
     if (persistedResumeInput) {
       const persistedConfig = resolveHarnessConfig(persistedResumeInput);
       if (persistedConfig.workspace !== initialConfig.workspace || persistedConfig.stateDirectory !== initialConfig.stateDirectory || persistedConfig.storeBackend !== initialConfig.storeBackend || JSON.stringify(persistedConfig.scope) !== JSON.stringify(initialConfig.scope)) {
         throw new Error("Resume locator options do not match the persisted workspace, state directory, store, or scope.");
       }
       persistedResumeOptions = harnessConfigInput(persistedConfig);
+      resumeCostBudget = persistedConfig.costBudget;
     }
+    assertRoutePricingIsSafe(persistedRoutes, resumeCostBudget);
     const harness = await createHarness({
       ...persistedResumeOptions,
       ...options,
       provider: state.provider,
       model: state.modelId,
+      subagentProfiles: [...new Set([
+        ...persistedResumeOptions.subagentProfiles ?? [],
+        ...persistedRoutes.keys()
+      ])],
+      subagentModels: createHarnessRouteModels(persistedRoutes),
       store: persistence.store,
       memory: persistence.memory,
-      onTelemetryEvent: orchestrationObserver(options.json)
+      onTelemetryEvent: orchestrationObserver(options.json || options.jsonl)
     });
     const approve = options.approve;
     const tracker = { streamedText: false };
@@ -4701,10 +5891,11 @@ ${summarizeApproval(approval)}
       state,
       approvals: approvalResponses(state.pendingApprovals, approve, approve ? "Approved by resume --approve." : "Denied by resume --deny.")
     }, {
-      onEvent: streamSink(options.json, tracker),
+      onEvent: streamSink(options, tracker),
       resolveApprovals: async (approvals) => approvalResponses(approvals, approve, approve ? "Approved by resume --approve." : "Denied by resume --deny.")
     });
-    printTerminalResult(result, harness, options.json, tracker.streamedText);
+    await updateIndexedSessionRun(harness.config, result.state.runId, result.status);
+    printTerminalResult(result, harness, options, tracker);
     if (result.status === "failed" || result.status === "timed_out") {
       process.exitCode = CLI_EXIT_CODES.runtimeError;
     }
@@ -4716,11 +5907,87 @@ var chat = async (options) => {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new Error("Chat mode requires an interactive terminal. Use run for automation.");
   }
-  const harness = await createHarness({ ...options, onTelemetryEvent: orchestrationObserver(false) });
+  const baseConfig = resolveHarnessConfig(options);
+  const sessionStore = await openSessionStoreForConfig(baseConfig);
   const readline = createInterface({ input: process.stdin, output: process.stdout });
+  let runtimeOptions = { ...options };
+  let routes = resolvedRouting(options);
+  const selectedSession = options.sessionId ? await sessionStore.get(options.sessionId) : options.continueSession ? await sessionStore.latest() : undefined;
+  if (options.sessionId && !selectedSession) {
+    sessionStore.close();
+    readline.close();
+    throw new Error(`Session ${options.sessionId} was not found.`);
+  }
+  let session = selectedSession ?? await sessionStore.create();
   let messages = [];
+  const latestState = async (selected) => {
+    const latest = selected.runs.at(-1);
+    if (!latest)
+      return;
+    const persistence = await openHarnessPersistence(baseConfig);
+    try {
+      const state = await persistence.store.load(latest.runId, baseConfig.scope);
+      if (!state)
+        throw new Error(`Run ${latest.runId} referenced by session ${selected.sessionId} was not found.`);
+      return state;
+    } finally {
+      persistence.close();
+    }
+  };
+  let harness;
+  try {
+    const restored = await latestState(session);
+    if (restored) {
+      runtimeOptions = { ...runtimeOptions, provider: restored.provider, model: restored.modelId };
+      routes = readHarnessResumeRoutes(restored);
+      messages = restored.messages;
+    }
+    harness = (await createConfiguredHarness(runtimeOptions, [], routes)).harness;
+  } catch (error) {
+    readline.close();
+    sessionStore.close();
+    throw error;
+  }
+  const refreshSession = async () => {
+    const refreshed = await sessionStore.get(session.sessionId);
+    if (!refreshed)
+      throw new Error(`Session ${session.sessionId} was not found.`);
+    session = refreshed;
+    return session;
+  };
+  const hasActiveTurn = async () => {
+    const latest = (await refreshSession()).runs.at(-1);
+    return latest && !["completed", "failed", "cancelled", "timed_out"].includes(latest.status) ? latest : undefined;
+  };
+  const replaceHarness = async (nextOptions, nextRoutes, extraProfiles = []) => {
+    const created = await createConfiguredHarness(nextOptions, extraProfiles, nextRoutes);
+    harness.close();
+    harness = created.harness;
+    runtimeOptions = nextOptions;
+    routes = new Map(nextRoutes);
+  };
+  const withTemporaryProfiles = async (profiles, operation) => {
+    const normalOptions = runtimeOptions;
+    const normalRoutes = new Map(routes);
+    return withTemporaryHarnessProfiles(profiles, (temporaryProfiles) => replaceHarness(normalOptions, normalRoutes, temporaryProfiles), operation);
+  };
+  const restoreSession = async (selected) => {
+    const state = await latestState(selected);
+    const nextOptions = state ? { ...runtimeOptions, provider: state.provider, model: state.modelId } : runtimeOptions;
+    const nextRoutes = state ? readHarnessResumeRoutes(state) : resolveHarnessModelRoutes();
+    await replaceHarness(nextOptions, nextRoutes);
+    session = selected;
+    messages = state?.messages ?? [];
+  };
+  const statusLine = async () => {
+    const current = await refreshSession();
+    const latest = current.runs.at(-1);
+    const routeText = routes.size === 0 ? "default" : [...routes.values()].map((route) => `${route.profile}=${route.provider}:${route.model}`).join(", ");
+    return `session ${current.sessionId} \xB7 ${harness.config.provider}/${harness.config.model}` + ` \xB7 ${messages.length} messages \xB7 routes ${routeText}` + `${latest ? ` \xB7 last ${latest.runId} (${latest.status})` : ""}`;
+  };
   process.stderr.write(`Zhivex Harness ${HARNESS_VERSION} \xB7 ${harness.config.provider}/${harness.config.model}
-` + `Type /exit to quit or /clear to clear the context.
+` + `session ${session.sessionId}
+` + `Type /help for console commands.
 `);
   try {
     for (;; ) {
@@ -4732,39 +5999,253 @@ var chat = async (options) => {
       if (prompt === "/exit" || prompt === "/quit") {
         break;
       }
+      if (prompt === "/help") {
+        process.stderr.write(`/provider [id] \xB7 /model [id] \xB7 /route [role=provider[:model]] \xB7 /status
+` + `/diff \xB7 /review <task> \xB7 /resume <last|sessionId> \xB7 /compact
+` + `/new [title] \xB7 /rename <title> \xB7 /clear \xB7 /exit
+`);
+        continue;
+      }
       if (prompt === "/clear") {
         messages = [];
         process.stderr.write(`Context cleared.
 `);
         continue;
       }
-      const tracker = { streamedText: false };
-      const result = await runHarness(harness, messages.length === 0 ? {
-        prompt,
-        scope: harness.config.scope,
-        metadata: createHarnessResumeMetadata(harness.config)
-      } : {
-        messages: appendUserMessage(messages, prompt),
-        scope: harness.config.scope,
-        metadata: createHarnessResumeMetadata(harness.config)
-      }, {
-        onEvent: streamSink(false, tracker),
-        resolveApprovals: terminalApprovalResolver(options.yes, (question) => readline.question(question))
+      if (prompt === "/status") {
+        process.stderr.write(`${await statusLine()}
+`);
+        continue;
+      }
+      if (prompt === "/diff") {
+        const diff = await harness.workspace.gitDiff();
+        const output = `${diff.status.stdout}${diff.diff.stdout}${diff.staged.stdout}`;
+        process.stdout.write(output || `No workspace changes.
+`);
+        continue;
+      }
+      if (prompt === "/compact") {
+        messages = compactHarnessMessages(messages);
+        process.stderr.write(`Context compacted to ${messages.length} redacted message(s).
+`);
+        continue;
+      }
+      if (prompt === "/provider" || prompt.startsWith("/provider ")) {
+        const value = prompt.slice("/provider".length).trim();
+        if (!value) {
+          process.stderr.write(`${providerAvailability().map((provider2) => `${provider2.id}${provider2.id === harness.config.provider ? "*" : ""}`).join(" ")}
+`);
+          continue;
+        }
+        const active2 = await hasActiveTurn();
+        if (active2) {
+          process.stderr.write(`Cannot switch provider while run ${active2.runId} is ${active2.status}.
+`);
+          continue;
+        }
+        const provider = parseProvider(value);
+        const model = DEFAULT_PROVIDER_REGISTRY.descriptor(provider).defaultModel;
+        const portableMessages = compactHarnessMessages(messages);
+        await replaceHarness({ ...runtimeOptions, provider, model }, routes);
+        messages = portableMessages;
+        process.stderr.write(`Next turn: ${provider}/${model}; context was compacted for a safe handoff.
+`);
+        continue;
+      }
+      if (prompt === "/model" || prompt.startsWith("/model ")) {
+        const value = prompt.slice("/model".length).trim();
+        if (!value) {
+          process.stderr.write(`${harness.config.provider}/${harness.config.model}
+`);
+          continue;
+        }
+        const active2 = await hasActiveTurn();
+        if (active2) {
+          process.stderr.write(`Cannot switch model while run ${active2.runId} is ${active2.status}.
+`);
+          continue;
+        }
+        const portableMessages = compactHarnessMessages(messages);
+        await replaceHarness({ ...runtimeOptions, model: value }, routes);
+        messages = portableMessages;
+        process.stderr.write(`Next turn: ${harness.config.provider}/${value}; context was compacted.
+`);
+        continue;
+      }
+      if (prompt === "/route" || prompt.startsWith("/route ")) {
+        const value = prompt.slice("/route".length).trim();
+        if (!value) {
+          process.stderr.write(`${JSON.stringify(serializeHarnessModelRoutes(routes))}
+`);
+          continue;
+        }
+        const active2 = await hasActiveTurn();
+        if (active2) {
+          process.stderr.write(`Cannot change routes while run ${active2.runId} is ${active2.status}.
+`);
+          continue;
+        }
+        const nextRoutes = new Map(routes);
+        if (value === "clear") {
+          nextRoutes.clear();
+        } else if (value.startsWith("clear ")) {
+          const profile = value.slice("clear ".length).trim();
+          if (!HARNESS_SUBAGENT_PROFILES.includes(profile)) {
+            process.stderr.write(`Unknown subagent profile: ${profile}.
+`);
+            continue;
+          }
+          nextRoutes.delete(profile);
+        } else {
+          const route = parseHarnessModelRoute(value);
+          nextRoutes.set(route.profile, route);
+        }
+        await replaceHarness(runtimeOptions, nextRoutes);
+        process.stderr.write(`Routes: ${JSON.stringify(serializeHarnessModelRoutes(routes))}
+`);
+        continue;
+      }
+      if (prompt === "/new" || prompt.startsWith("/new ")) {
+        const active2 = await hasActiveTurn();
+        if (active2) {
+          process.stderr.write(`Cannot leave session while run ${active2.runId} is ${active2.status}.
+`);
+          continue;
+        }
+        const title = prompt.slice("/new".length).trim();
+        const created = await sessionStore.create(title ? { title } : undefined);
+        await restoreSession(created);
+        process.stderr.write(`Created session ${session.sessionId}.
+`);
+        continue;
+      }
+      if (prompt === "/rename" || prompt.startsWith("/rename ")) {
+        const title = prompt.slice("/rename".length).trim();
+        if (!title) {
+          process.stderr.write(`Usage: /rename <title>
+`);
+          continue;
+        }
+        session = await sessionStore.rename(session.sessionId, title);
+        process.stderr.write(`Renamed session to ${session.title}.
+`);
+        continue;
+      }
+      if (prompt === "/resume" || prompt.startsWith("/resume ")) {
+        const selector = prompt.slice("/resume".length).trim() || "last";
+        const selected = selector === "last" ? await sessionStore.latest({ includeArchived: true }) : await sessionStore.get(selector);
+        if (!selected) {
+          process.stderr.write(`Session ${selector} was not found.
+`);
+          continue;
+        }
+        await restoreSession(selected);
+        const active2 = await hasActiveTurn();
+        process.stderr.write(active2 ? `Session ${session.sessionId} has run ${active2.runId} waiting in ${active2.status}; use zhx resume ${active2.runId} --approve|--deny.
+` : `Resumed session ${session.sessionId}.
+`);
+        continue;
+      }
+      if (prompt === "/review" || prompt.startsWith("/review ")) {
+        const reviewPrompt = prompt.slice("/review".length).trim();
+        if (!reviewPrompt) {
+          process.stderr.write(`Usage: /review <task>
+`);
+          continue;
+        }
+        const active2 = await hasActiveTurn();
+        if (active2) {
+          process.stderr.write(`Cannot start a review while run ${active2.runId} is ${active2.status}.
+`);
+          continue;
+        }
+        const review = await withTemporaryProfiles(["explorer", "reviewer"], () => runHarnessReviewGroup(harness, { prompt: reviewPrompt, scope: harness.config.scope }, ["explorer", "reviewer"]));
+        for (const output of review.outputs) {
+          process.stdout.write(`
+[${output.name ?? output.agentId ?? "reviewer"}] ${output.status}
+`);
+          if (output.output?.outputText)
+            process.stdout.write(`${output.output.outputText}
+`);
+        }
+        continue;
+      }
+      const active = await hasActiveTurn();
+      if (active) {
+        process.stderr.write(`Run ${active.runId} is ${active.status}; resolve it with zhx resume ${active.runId} --approve|--deny before a new turn.
+`);
+        continue;
+      }
+      const runId = `run_${randomUUID5()}`;
+      session = await sessionStore.appendRun(session.sessionId, {
+        runId,
+        provider: harness.config.provider,
+        model: harness.config.model,
+        status: "created"
       });
+      const turn = session.runs.at(-1);
+      const tracker = { streamedText: false };
+      let markedRunning = false;
+      let result;
+      try {
+        result = await runHarness(harness, messages.length === 0 ? {
+          runId,
+          prompt,
+          scope: harness.config.scope,
+          metadata: {
+            ...createHarnessResumeMetadata(harness.config, routes),
+            zhivexCliSession: {
+              schemaVersion: 1,
+              sessionId: session.sessionId,
+              turnId: turn.turnId,
+              sequence: turn.sequence
+            }
+          }
+        } : {
+          runId,
+          messages: appendUserMessage(messages, prompt),
+          scope: harness.config.scope,
+          metadata: {
+            ...createHarnessResumeMetadata(harness.config, routes),
+            zhivexCliSession: {
+              schemaVersion: 1,
+              sessionId: session.sessionId,
+              turnId: turn.turnId,
+              sequence: turn.sequence
+            }
+          }
+        }, {
+          onEvent: async (event) => {
+            if (!markedRunning && event.type === "agent-run-start") {
+              session = await sessionStore.updateRun(session.sessionId, runId, { status: "running" });
+              markedRunning = true;
+            }
+            await streamSink({ json: false, jsonl: false }, tracker)(event);
+          },
+          resolveApprovals: terminalApprovalResolver(options.yes, (question) => readline.question(question))
+        });
+      } catch (error) {
+        session = await sessionStore.updateRun(session.sessionId, runId, { status: "failed" });
+        throw error;
+      }
       if (!tracker.streamedText && result.outputText) {
         process.stdout.write(result.outputText);
       }
       process.stdout.write(`
 `);
       messages = result.messages;
+      session = await sessionStore.updateRun(session.sessionId, runId, {
+        status: sessionStatus(result.status)
+      });
       if (result.status === "waiting_approval") {
-        process.stderr.write(`Run paused: ${result.state.runId}
+        process.stderr.write(`Run paused: ${result.state.runId}. Resume with zhx resume ${result.state.runId} --approve|--deny.
 `);
       }
     }
   } finally {
     readline.close();
     harness.close();
+    sessionStore.close();
   }
 };
 var providersDocument = (env = process.env) => ({
@@ -4819,7 +6300,7 @@ var satisfiesBunEngine = (version, range) => {
 var diagnostic = (id, status, message, details = {}) => ({ id, status, message, details });
 var inspectWorkspace = async (workspace) => {
   try {
-    const workspaceStat = await stat3(workspace);
+    const workspaceStat = await stat4(workspace);
     if (!workspaceStat.isDirectory()) {
       return diagnostic("workspace", "fail", "Workspace is not a directory.", { path: workspace });
     }
@@ -4861,9 +6342,9 @@ var inspectGit = async (workspace) => {
   }
 };
 var inspectScripts = async (workspace, allowedChecks) => {
-  const packagePath = path8.join(workspace, "package.json");
+  const packagePath = path9.join(workspace, "package.json");
   try {
-    const packageStat = await stat3(packagePath);
+    const packageStat = await stat4(packagePath);
     if (!packageStat.isFile() || packageStat.size > 1024 * 1024) {
       return diagnostic("scripts", "warn", "package.json is not a readable regular file.", {
         packageJson: false,
@@ -4885,17 +6366,17 @@ var inspectScripts = async (workspace, allowedChecks) => {
   }
 };
 var isInsidePath2 = (root, candidate) => {
-  const relative = path8.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path8.sep}`) && relative !== ".." && !path8.isAbsolute(relative);
+  const relative = path9.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path9.sep}`) && relative !== ".." && !path9.isAbsolute(relative);
 };
 var containsSymlink = async (candidate, trustedPrefix) => {
-  const parsed = path8.parse(candidate);
-  const parts = trustedPrefix ? path8.relative(trustedPrefix, candidate).split(path8.sep).filter(Boolean) : candidate.slice(parsed.root.length).split(path8.sep).filter(Boolean).slice(1);
-  let current = trustedPrefix ?? path8.join(parsed.root, candidate.slice(parsed.root.length).split(path8.sep).filter(Boolean)[0] ?? "");
+  const parsed = path9.parse(candidate);
+  const parts = trustedPrefix ? path9.relative(trustedPrefix, candidate).split(path9.sep).filter(Boolean) : candidate.slice(parsed.root.length).split(path9.sep).filter(Boolean).slice(1);
+  let current = trustedPrefix ?? path9.join(parsed.root, candidate.slice(parsed.root.length).split(path9.sep).filter(Boolean)[0] ?? "");
   for (const part of parts) {
-    current = path8.join(current, part);
+    current = path9.join(current, part);
     try {
-      if ((await lstat6(current)).isSymbolicLink()) {
+      if ((await lstat7(current)).isSymbolicLink()) {
         return true;
       }
     } catch (error) {
@@ -4911,12 +6392,12 @@ var nearestExistingPath = async (candidate) => {
   let current = candidate;
   for (;; ) {
     try {
-      return { path: current, stat: await stat3(current) };
+      return { path: current, stat: await stat4(current) };
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
-      const parent = path8.dirname(current);
+      const parent = path9.dirname(current);
       if (parent === current) {
         throw error;
       }
@@ -4932,7 +6413,7 @@ var inspectStateDirectory = async (workspace, stateDirectory) => {
     });
   }
   if (isInsidePath2(workspace, stateDirectory)) {
-    const segments = path8.relative(workspace, stateDirectory).split(path8.sep).filter(Boolean);
+    const segments = path9.relative(workspace, stateDirectory).split(path9.sep).filter(Boolean);
     const sensitiveSegment = segments.find(isSensitiveStateSegment);
     if (sensitiveSegment) {
       return diagnostic("state-directory", "fail", "State directory is inside a sensitive workspace path.", {
@@ -4979,9 +6460,9 @@ var inspectOperationsStore = async (stateDirectory, storeBackend) => {
       migrationAvailable: true
     });
   }
-  const databasePath = path8.join(stateDirectory, "operations.sqlite");
+  const databasePath = path9.join(stateDirectory, "operations.sqlite");
   try {
-    const entry = await lstat6(databasePath);
+    const entry = await lstat7(databasePath);
     if (entry.isSymbolicLink() || !entry.isFile()) {
       return diagnostic("operations-store", "fail", "SQLite state path is not a regular file.", {
         backend: storeBackend,
@@ -5269,6 +6750,95 @@ var manageRuns = async (options) => {
     persistence.close();
   }
 };
+var openSessionStoreForConfig = (config) => openCliSessionStore({
+  workspace: config.workspace,
+  stateDirectory: config.stateDirectory,
+  scope: config.scope
+});
+var printSessionDocument = (document, json) => {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(document, null, 2)}
+`);
+    return;
+  }
+  const record = document;
+  if (record.kind === "session-list") {
+    for (const session2 of record.sessions ?? []) {
+      const latest = session2.runs.at(-1);
+      process.stdout.write(`${session2.sessionId} ${session2.title ?? "(untitled)"} \xB7 ${session2.runs.length} runs` + `${latest ? ` \xB7 ${latest.provider}/${latest.model} \xB7 ${latest.status}` : ""}
+`);
+    }
+    return;
+  }
+  const session = record.session;
+  if (session) {
+    process.stdout.write(`${session.sessionId} \xB7 ${session.title ?? "(untitled)"} \xB7 ${session.runs.length} runs` + `${session.archivedAt ? " \xB7 archived" : ""}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(document, null, 2)}
+`);
+};
+var manageSessions = async (options) => {
+  const config = resolveHarnessConfig(options);
+  const store = await openSessionStoreForConfig(config);
+  try {
+    let session;
+    let document;
+    switch (options.sessionsCommand) {
+      case "list": {
+        const summaries = await store.list(options.limit ? { limit: options.limit } : undefined);
+        const sessions = (await Promise.all(summaries.map((summary) => store.get(summary.sessionId)))).filter((value) => Boolean(value));
+        document = { schemaVersion: CLI_JSON_SCHEMA_VERSION, kind: "session-list", sessions };
+        break;
+      }
+      case "inspect":
+        session = await store.get(options.sessionId);
+        if (!session)
+          throw new Error(`Session ${options.sessionId} was not found.`);
+        document = { schemaVersion: CLI_JSON_SCHEMA_VERSION, kind: "session", session };
+        break;
+      case "rename":
+        session = await store.rename(options.sessionId, options.sessionTitle);
+        document = { schemaVersion: CLI_JSON_SCHEMA_VERSION, kind: "session", session };
+        break;
+      case "fork":
+        session = await store.fork(options.sessionId);
+        document = { schemaVersion: CLI_JSON_SCHEMA_VERSION, kind: "session", session };
+        break;
+      case "archive":
+        session = await store.archive(options.sessionId);
+        document = { schemaVersion: CLI_JSON_SCHEMA_VERSION, kind: "session", session };
+        break;
+      default:
+        throw new CliUsageError("sessions requires one of: list, inspect, rename, fork, archive.");
+    }
+    printSessionDocument(document, options.json);
+  } finally {
+    store.close();
+  }
+};
+var sessionStatus = (status) => {
+  if (status === "queued")
+    return "created";
+  if (status === "suspended")
+    return "waiting_approval";
+  return status;
+};
+var updateIndexedSessionRun = async (config, runId, status) => {
+  const store = await openSessionStoreForConfig(config);
+  try {
+    for (const summary of await store.list({ limit: 200, includeArchived: true })) {
+      const session = await store.get(summary.sessionId);
+      if (session?.runs.some((run) => run.runId === runId)) {
+        await store.updateRun(session.sessionId, runId, { status: sessionStatus(status) });
+        return;
+      }
+    }
+  } finally {
+    store.close();
+  }
+};
 var cliExitCodeForError = (error) => error instanceof CliUsageError ? CLI_EXIT_CODES.usageError : CLI_EXIT_CODES.runtimeError;
 var main = async (argv = process.argv.slice(2)) => {
   const options = parseCliArgs(argv);
@@ -5296,7 +6866,14 @@ var main = async (argv = process.argv.slice(2)) => {
     case "runs":
       await manageRuns(options);
       return;
+    case "sessions":
+      await manageSessions(options);
+      return;
     case "run":
+      if (options.implicitCommand && !options.prompt && process.stdin.isTTY && process.stdout.isTTY) {
+        await chat(options);
+        return;
+      }
       await runOnce(options);
       return;
     case "review":
@@ -5312,9 +6889,11 @@ if (import.meta.main) {
   });
 }
 export {
+  withTemporaryHarnessProfiles,
   summarizeApproval,
   runResultDocument,
   resumeCommand,
+  readHarnessResumeRoutes,
   readHarnessResumeConfig,
   providersDocument,
   parseCliArgs,