@zhivex-ai/harness 1.0.0 → 1.1.0-rc.3

package/dist/approvals/approval-diff.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import type { AgentRunState } from "@zhivex-ai/core";
+import type { HarnessClientRun } from "../client/protocol.js";
+import type { ApprovalDecisionView } from "./approval-history.js";
+export declare const APPROVAL_DIFFS_KEY = "clientApprovalDiffsV1";
+declare const file: z.ZodObject<{
+    path: z.ZodString;
+    expectedDigest: z.ZodNullable<z.ZodString>;
+    before: z.ZodNullable<z.ZodString>;
+    after: z.ZodNullable<z.ZodString>;
+    afterDigest: z.ZodNullable<z.ZodString>;
+    beforeMode: z.ZodOptional<z.ZodNumber>;
+    afterMode: z.ZodOptional<z.ZodNumber>;
+    operation: z.ZodOptional<z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        update: "update";
+    }>>;
+}, z.core.$strict>;
+export type AppliedDiff = {
+    status: "complete";
+    files: z.infer<typeof file>[];
+    redacted?: boolean;
+} | {
+    status: "unavailable";
+};
+/** Capture complete previews before admitting execution, bounded across the run. */
+export declare function captureApprovalDiffs(state: AgentRunState, run: HarnessClientRun, approved: ReadonlySet<string>): {
+    approvalId: string;
+    digest: string;
+    proposalId: string;
+    files: {
+        path: string;
+        expectedDigest: string | null;
+        before: string | null;
+        after: string | null;
+        afterDigest: string | null;
+        beforeMode?: number | undefined;
+        afterMode?: number | undefined;
+        operation?: "create" | "delete" | "update" | undefined;
+    }[];
+}[];
+/** Only expose saved content when exact journal effects certify every file. */
+export declare function attachAppliedDiffs(state: AgentRunState, decisions: ApprovalDecisionView[]): ApprovalDecisionView[];
+export {};

package/dist/approvals/approval-history.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import type { AgentRunState, AgentToolCallJournalEntry } from "@zhivex-ai/core";
+import type { AppliedDiff } from "./approval-diff.js";
+export declare const APPROVAL_HISTORY_KEY = "clientApprovalDecisionsV1";
+export declare const approvalInputDigest: (value: unknown) => string;
+declare const rowSchema: z.ZodObject<{
+    approvalId: z.ZodString;
+    digest: z.ZodString;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    inputDigest: z.ZodOptional<z.ZodString>;
+    approved: z.ZodBoolean;
+    decidedAt: z.ZodNumber;
+    reviewedRevision: z.ZodNumber;
+}, z.core.$strict>;
+export type ApprovalDecisionRecord = z.infer<typeof rowSchema>;
+export interface ApprovalDecisionView extends ApprovalDecisionRecord {
+    status: "rejected" | "approved" | "applied" | "succeeded" | "failed" | "unknown";
+    finalDiff?: AppliedDiff;
+    evidence?: {
+        journalRevision: number;
+        completedAt?: number;
+        exitCode?: number;
+        timedOut?: boolean;
+        proposalId?: string;
+        reviewedProposalId?: string;
+        verifiedPatchId?: string;
+        command?: string[];
+        effects?: Array<{
+            path: string;
+            beforeDigest: string | null;
+            afterDigest: string | null;
+        }>;
+    };
+}
+export declare function readApprovalDecisions(state: AgentRunState): ApprovalDecisionRecord[];
+export declare function approvalDecisionViews(state: AgentRunState, journal: readonly AgentToolCallJournalEntry[], offset?: number): ApprovalDecisionView[];
+export {};

package/dist/approvals/approval-preview.d.ts

@@ -0,0 +1,26 @@
+import type { HarnessOciExecutionEnvironment } from "../execution/execution-environment.js";
+import type { AgentStoreScope } from "@zhivex-ai/core";
+import type { Workspace } from "../workspace/workspace.js";
+import type { HarnessClientRun } from "../client/protocol.js";
+export interface ApprovalPreviewFile {
+    path: string;
+    expectedDigest: string | null;
+    before: string | null;
+    after: string | null;
+    afterDigest: string | null;
+    beforeMode?: number;
+    afterMode?: number;
+    operation?: "create" | "update" | "delete";
+}
+export type ApprovalFilePreview = {
+    status: "complete";
+    proposalId: string;
+    files: ApprovalPreviewFile[];
+} | {
+    status: "unavailable";
+};
+/** Explicitly requested read projection; never trusts renderer-supplied paths or changes. */
+export declare function attachApprovalPreviews(run: HarnessClientRun, workspace: Workspace, options?: {
+    environment?: HarnessOciExecutionEnvironment | undefined;
+    scope?: AgentStoreScope | undefined;
+}): Promise<HarnessClientRun>;

package/dist/cli/arguments.d.ts

@@ -0,0 +1,103 @@
+import { type AgentStatus } from "@zhivex-ai/agents";
+import { type HarnessSubagentProfile } from "../runtime/config.js";
+import { HarnessError } from "../runtime/errors.js";
+export declare const CLI_COMMANDS: readonly ["init", "run", "review", "chat", "providers", "doctor", "resume", "runs", "sessions", "changes", "state", "help", "version"];
+export declare const CLI_RUNS_COMMANDS: readonly ["list", "inspect", "cancel", "cleanup", "export"];
+export declare const CLI_SESSIONS_COMMANDS: readonly ["list", "inspect", "rename", "fork", "archive"];
+export declare const CLI_CHANGES_COMMANDS: readonly ["create", "verify"];
+export declare const CLI_STATE_COMMANDS: readonly ["status", "export", "import"];
+type Command = (typeof CLI_COMMANDS)[number];
+type RunsCommand = (typeof CLI_RUNS_COMMANDS)[number];
+type SessionsCommand = (typeof CLI_SESSIONS_COMMANDS)[number];
+type ChangesCommand = (typeof CLI_CHANGES_COMMANDS)[number];
+type StateCommand = (typeof CLI_STATE_COMMANDS)[number];
+export interface CliOptions {
+    serviceFile?: string;
+    command: Command;
+    helpTopic?: string;
+    profile?: string;
+    provider?: string;
+    model?: string;
+    workspace?: string;
+    stateDirectory?: string;
+    storeBackend?: string;
+    tenantId?: string;
+    userId?: string;
+    namespace?: string;
+    maxSteps?: number;
+    timeoutMs?: number;
+    maxToolCalls?: number;
+    maxToolErrors?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxTotalTokens?: number;
+    maxCostUsd?: number;
+    inputCostPerMillion?: number;
+    outputCostPerMillion?: number;
+    allowedChecks?: string[];
+    requiredCapabilities?: string[];
+    subagentProfiles?: HarnessSubagentProfile[];
+    reviewers?: HarnessSubagentProfile[];
+    routes?: string[];
+    subagentMaxSteps?: number;
+    subagentMaxToolCalls?: number;
+    subagentMaxToolErrors?: number;
+    subagentMaxInputTokens?: number;
+    subagentMaxOutputTokens?: number;
+    subagentMaxTotalTokens?: number;
+    subagentTimeoutMs?: number;
+    maxParallelReviews?: number;
+    executionBackend?: string;
+    agentProfile?: string;
+    ociRuntime?: string;
+    ociImage?: string;
+    ociAllowedCommands?: string[];
+    ociShellMode?: string;
+    ociMaxProcessRuntimeMs?: number;
+    ociMaxProcessOutputBytes?: number;
+    ociMaxMemoryMb?: number;
+    ociMaxPids?: number;
+    ociMaxCpus?: number;
+    ociMaxWorkspaceBytes?: number;
+    ociMaxFileWriteBytes?: number;
+    ociTmpfsMb?: number;
+    mcpConfigPath?: string;
+    contextConfigPath?: string;
+    projectContext?: boolean;
+    prompt?: string;
+    runId?: string;
+    idempotencyKey?: string;
+    runsCommand?: RunsCommand;
+    sessionsCommand?: SessionsCommand;
+    changesCommand?: ChangesCommand;
+    stateCommand?: StateCommand;
+    artifactPath?: string;
+    patchPath?: string;
+    preconditionsPath?: string;
+    verificationTime?: string;
+    backupPath?: string;
+    sessionId?: string;
+    sessionTitle?: string;
+    sessionSearch?: string;
+    pricingFile?: string;
+    usageLimitUsd?: number;
+    continueSession: boolean;
+    implicitCommand: boolean;
+    statuses?: AgentStatus[];
+    limit?: number;
+    cursor?: string;
+    before?: number;
+    reason?: string;
+    cascade: boolean;
+    final: boolean;
+    apply: boolean;
+    yes: boolean;
+    approve?: boolean;
+    json: boolean;
+    jsonl: boolean;
+}
+export declare class CliUsageError extends HarnessError {
+    constructor(message: string);
+}
+export declare const parseCliArgs: (argv: string[]) => CliOptions;
+export {};

package/dist/cli/changes.d.ts

@@ -0,0 +1,2 @@
+import { type CliOptions } from "./arguments.js";
+export declare const manageChanges: (options: CliOptions) => Promise<void>;

package/dist/cli/cli-credentials.d.ts

@@ -0,0 +1,38 @@
+import { type HarnessProvider } from "../runtime/config.js";
+export interface SecretEntry {
+    getPassword(): Promise<string | null | undefined>;
+    setPassword(value: string): Promise<void>;
+    deleteCredential(): Promise<boolean>;
+}
+export interface CredentialInput {
+    select<T>(title: string, items: readonly {
+        value: T;
+        label: string;
+        detail?: string;
+    }[]): Promise<T | undefined>;
+    secret(prompt: string): Promise<string>;
+}
+export type EntryFactory = (provider: string) => Promise<SecretEntry>;
+export declare const credentialService = "ai.zhivex.harness.cli";
+export declare const validCredential: (value: string) => boolean;
+export declare const nativeCredentialEntry: EntryFactory;
+/** CLI session only. Never put this object or its secrets in run metadata or process.env. */
+export declare class CliCredentials {
+    private readonly entry;
+    private readonly environment;
+    private readonly write;
+    private readonly temporary;
+    revision: number;
+    constructor(entry?: EntryFactory, environment?: NodeJS.ProcessEnv, write?: (text: string) => void);
+    private environmentKey;
+    private validate;
+    private saved;
+    configure(provider: HarnessProvider, input: CredentialInput): Promise<boolean>;
+    providerEnvironment(provider: HarnessProvider, input: CredentialInput): Promise<NodeJS.ProcessEnv>;
+    clear(): void;
+}
+/** Keep provider error payloads out of durable runs when they can contain a key. */
+export declare function credentialModel(config: {
+    provider: HarnessProvider;
+    model: string;
+}, env: NodeJS.ProcessEnv, modelFactory?: typeof import("../runtime/config.js").createProviderModel): Promise<import("@zhivex-ai/agents").LanguageModel<import("@zhivex-ai/core").ProviderOptions>>;

package/dist/cli/cli-help.d.ts

@@ -0,0 +1,3 @@
+export declare const shortCliHelp: (version: string) => string;
+export declare function resolveHelpTopic(parts: string[], explicit: boolean): string | undefined;
+export declare function formatCliHelp(topic: string | undefined, version: string, full: string): string;

package/dist/{cli-options.d.ts → cli/cli-options.d.ts}

@@ -8,7 +8,7 @@ export interface CliCommandOptionContract {
     repeatable: readonly string[];
     conflicts: Readonly<Record<string, readonly string[]>>;
 }
-export declare const CLI_OPTION_NAMES: readonly ["--provider", "--model", "--profile", "--route", "--workspace", "--state-dir", "--mcp-config", "--context-config", "--no-project-context", "--patch", "--preconditions", "--now", "--agent-profile", "--execution", "--oci-runtime", "--oci-image", "--oci-allow-command", "--oci-shell", "--oci-max-process-runtime-ms", "--oci-max-process-output-bytes", "--oci-max-memory-mb", "--oci-max-pids", "--oci-max-cpus", "--oci-max-workspace-bytes", "--oci-max-file-write-bytes", "--oci-tmpfs-mb", "--store", "--tenant", "--user", "--namespace", "--idempotency-key", "--max-steps", "--timeout-ms", "--max-tool-calls", "--max-tool-errors", "--max-input-tokens", "--max-output-tokens", "--max-total-tokens", "--subagent-max-steps", "--subagent-max-tool-calls", "--subagent-max-tool-errors", "--subagent-max-input-tokens", "--subagent-max-output-tokens", "--subagent-max-total-tokens", "--subagent-timeout-ms", "--max-parallel-reviews", "--max-cost-usd", "--input-cost-per-million", "--output-cost-per-million", "--allow-check", "--require-capability", "--subagent", "--reviewer", "--yes", "--approve", "--deny", "--json", "--jsonl", "--session", "--continue", "--status", "--limit", "--cursor", "--before", "--reason", "--cascade", "--final", "--apply", "--help", "--version"];
+export declare const CLI_OPTION_NAMES: readonly ["--provider", "--model", "--profile", "--route", "--workspace", "--state-dir", "--mcp-config", "--context-config", "--no-project-context", "--patch", "--preconditions", "--now", "--agent-profile", "--execution", "--oci-runtime", "--oci-image", "--oci-allow-command", "--oci-shell", "--oci-max-process-runtime-ms", "--oci-max-process-output-bytes", "--oci-max-memory-mb", "--oci-max-pids", "--oci-max-cpus", "--oci-max-workspace-bytes", "--oci-max-file-write-bytes", "--oci-tmpfs-mb", "--store", "--tenant", "--user", "--namespace", "--idempotency-key", "--max-steps", "--timeout-ms", "--max-tool-calls", "--max-tool-errors", "--max-input-tokens", "--max-output-tokens", "--max-total-tokens", "--subagent-max-steps", "--subagent-max-tool-calls", "--subagent-max-tool-errors", "--subagent-max-input-tokens", "--subagent-max-output-tokens", "--subagent-max-total-tokens", "--subagent-timeout-ms", "--max-parallel-reviews", "--max-cost-usd", "--input-cost-per-million", "--output-cost-per-million", "--allow-check", "--require-capability", "--subagent", "--reviewer", "--yes", "--approve", "--deny", "--json", "--jsonl", "--session", "--continue", "--status", "--limit", "--cursor", "--before", "--reason", "--cascade", "--final", "--service", "--apply", "--help", "--version", "--search", "--pricing-file", "--usage-limit-usd"];
 export type CliOptionName = (typeof CLI_OPTION_NAMES)[number];
 export declare const CLI_OPTION_DEFINITIONS: Readonly<Record<CliOptionName, CliOptionDefinition>>;
 export declare const CLI_COMMAND_OPTION_CONTRACTS: {

package/dist/{cli-profiles.d.ts → cli/cli-profiles.d.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type HarnessConfigInput, type HarnessProvider } from "./config.js";
+import { type HarnessConfigInput, type HarnessProvider } from "../runtime/config.js";
 export declare const CLI_PROFILE_SCHEMA_VERSION: 1;
 export declare const CLI_PROFILE_CONFIG_DIRECTORY_ENV: "ZHIVEX_HARNESS_CONFIG_DIR";
 export declare const MAX_CLI_PROFILE_BYTES: number;

package/dist/cli/configured-harness.d.ts

@@ -0,0 +1,12 @@
+import { CliCredentials } from "./cli-credentials.js";
+import { ConsoleInput } from "./console/console-input.js";
+import { type HarnessSubagentProfile } from "../runtime/config.js";
+import { type HarnessModelRoute } from "../providers/routing.js";
+import { type CliOptions } from "./arguments.js";
+export declare const createConfiguredHarness: (options: CliOptions, extraProfiles?: readonly HarnessSubagentProfile[], persistedRoutes?: ReadonlyMap<HarnessSubagentProfile, HarnessModelRoute>, credentials?: {
+    store: CliCredentials;
+    input: ConsoleInput;
+}) => Promise<{
+    harness: import("../index.js").ZhivexHarness;
+    routes: ReadonlyMap<"explorer" | "implementer" | "reviewer" | "tester", HarnessModelRoute>;
+}>;

package/dist/cli/console/console-commands.d.ts

@@ -0,0 +1,6 @@
+/** Presentation shared by the direct console and the local-service client. */
+export declare const CONSOLE_COMMAND_CATALOG: readonly [readonly ["/menu", "Open navigation menu", true], readonly ["/help", "Show commands; /help all shows everything", true], readonly ["/credentials", "Manage provider keys in the system keychain or this session", false], readonly ["/provider", "Select a provider", false], readonly ["/model", "Select a model", false], readonly ["/route", "Configure specialist model routes", false], readonly ["/status", "Inspect the current session and run", true], readonly ["/diff", "Review workspace changes", false], readonly ["/review", "Review a task", false], readonly ["/resume", "Reopen a conversation by session ID", true], readonly ["/pending", "Inspect pending approvals", true], readonly ["/approve", "Approve the pending actions", true], readonly ["/deny", "Deny the pending actions", true], readonly ["/compact", "Compact conversation context", false], readonly ["/new", "Start a new conversation", true], readonly ["/rename", "Rename the current conversation", true], readonly ["/clear", "Clear conversation context", false], readonly ["/exit", "Exit the console", true], readonly ["/paste", "Compose a literal multiline draft", true], readonly ["/verbose", "Toggle full or compact activity details", false], readonly ["/context", "Inspect project rules and selected context", false], readonly ["/attach", "Attach a workspace file to the next request", false], readonly ["/attachments", "List selected attachments", false], readonly ["/detach", "Remove selected attachments", false], readonly ["/sessions", "Find saved conversations", true], readonly ["/usage", "Inspect transport usage", false], readonly ["/cancel", "Cancel the active run", true]];
+export type ConsoleMode = "direct" | "service";
+export declare const consoleCommands: (mode?: ConsoleMode) => (readonly ["/approve", "Approve the pending actions", true] | readonly ["/attach", "Attach a workspace file to the next request", false] | readonly ["/attachments", "List selected attachments", false] | readonly ["/cancel", "Cancel the active run", true] | readonly ["/clear", "Clear conversation context", false] | readonly ["/compact", "Compact conversation context", false] | readonly ["/context", "Inspect project rules and selected context", false] | readonly ["/credentials", "Manage provider keys in the system keychain or this session", false] | readonly ["/deny", "Deny the pending actions", true] | readonly ["/detach", "Remove selected attachments", false] | readonly ["/diff", "Review workspace changes", false] | readonly ["/exit", "Exit the console", true] | readonly ["/help", "Show commands; /help all shows everything", true] | readonly ["/menu", "Open navigation menu", true] | readonly ["/model", "Select a model", false] | readonly ["/new", "Start a new conversation", true] | readonly ["/paste", "Compose a literal multiline draft", true] | readonly ["/pending", "Inspect pending approvals", true] | readonly ["/provider", "Select a provider", false] | readonly ["/rename", "Rename the current conversation", true] | readonly ["/resume", "Reopen a conversation by session ID", true] | readonly ["/review", "Review a task", false] | readonly ["/route", "Configure specialist model routes", false] | readonly ["/sessions", "Find saved conversations", true] | readonly ["/status", "Inspect the current session and run", true] | readonly ["/usage", "Inspect transport usage", false] | readonly ["/verbose", "Toggle full or compact activity details", false])[];
+export declare const searchConsoleCommands: (query: string, mode?: ConsoleMode) => (readonly ["/approve", "Approve the pending actions", true] | readonly ["/attach", "Attach a workspace file to the next request", false] | readonly ["/attachments", "List selected attachments", false] | readonly ["/cancel", "Cancel the active run", true] | readonly ["/clear", "Clear conversation context", false] | readonly ["/compact", "Compact conversation context", false] | readonly ["/context", "Inspect project rules and selected context", false] | readonly ["/credentials", "Manage provider keys in the system keychain or this session", false] | readonly ["/deny", "Deny the pending actions", true] | readonly ["/detach", "Remove selected attachments", false] | readonly ["/diff", "Review workspace changes", false] | readonly ["/exit", "Exit the console", true] | readonly ["/help", "Show commands; /help all shows everything", true] | readonly ["/menu", "Open navigation menu", true] | readonly ["/model", "Select a model", false] | readonly ["/new", "Start a new conversation", true] | readonly ["/paste", "Compose a literal multiline draft", true] | readonly ["/pending", "Inspect pending approvals", true] | readonly ["/provider", "Select a provider", false] | readonly ["/rename", "Rename the current conversation", true] | readonly ["/resume", "Reopen a conversation by session ID", true] | readonly ["/review", "Review a task", false] | readonly ["/route", "Configure specialist model routes", false] | readonly ["/sessions", "Find saved conversations", true] | readonly ["/status", "Inspect the current session and run", true] | readonly ["/usage", "Inspect transport usage", false] | readonly ["/verbose", "Toggle full or compact activity details", false])[];
+export declare const formatConsoleHelp: (mode?: ConsoleMode, all?: boolean) => string;

package/dist/{console-context.d.ts → cli/console/console-context.d.ts}

@@ -1,6 +1,10 @@
-import type { ZhivexHarness } from "./harness.js";
-import type { Workspace } from "./workspace.js";
-export declare const formatConsoleContext: (context: ZhivexHarness["context"]) => string;
+import type { ZhivexHarness } from "../../runtime/harness.js";
+import type { Workspace } from "../../workspace/workspace.js";
+export declare const formatConsoleContext: (context: ZhivexHarness["context"], options?: {
+    attachments: ReturnType<ConsoleAttachments["list"]>;
+    config: ZhivexHarness["config"];
+    messages: unknown[];
+}) => string;
 export declare const formatConsoleDiff: (diff: string, color: boolean) => string;
 /** Explicit attachments use the same bounded, secret-excluding reads as model tools. */
 export declare class ConsoleAttachments {

package/dist/cli/console/console-input.d.ts

@@ -0,0 +1,68 @@
+import { type Readable, Writable } from "node:stream";
+import { type ConsoleMode } from "./console-commands.js";
+export declare const CONSOLE_COMMANDS: ("/approve" | "/attach" | "/attachments" | "/cancel" | "/clear" | "/compact" | "/context" | "/credentials" | "/deny" | "/detach" | "/diff" | "/exit" | "/help" | "/menu" | "/model" | "/new" | "/paste" | "/pending" | "/provider" | "/rename" | "/resume" | "/review" | "/route" | "/sessions" | "/status" | "/usage" | "/verbose")[];
+export declare const MAX_CONSOLE_INPUT_BYTES: number;
+export declare const completeConsoleCommand: (line: string) => [string[], string];
+/** Lines received without an active question are discarded, never replayed as approvals. */
+export declare class ConsoleInput {
+    private readonly input;
+    private readonly output;
+    private readonly terminal;
+    private readonly mode;
+    private hidden;
+    private readonly reader;
+    private readonly keyboard;
+    private readonly display;
+    private readonly decoder;
+    private escape;
+    private clipboard;
+    private clipboardBytes;
+    private clipboardAllowed;
+    private draftWasPaste;
+    lastSubmissionWasPaste: boolean;
+    private closed;
+    private completeCommands;
+    private history;
+    private historyPosition;
+    private historyDraft;
+    private historyDraftWasPaste;
+    private pending;
+    private paste;
+    onInterrupt: (() => void) | undefined;
+    constructor(input: Readable, output: Writable, terminal?: boolean, mode?: ConsoleMode);
+    private selection;
+    private selectionMatches;
+    private finishSelection;
+    select<T>(title: string, items: readonly {
+        value: T;
+        label: string;
+        detail?: string;
+    }[]): Promise<T | undefined>;
+    private taskPrompt;
+    private shortcutsShown;
+    private historySearch;
+    private historyMatches;
+    private finishHistorySearch;
+    private menuVisible;
+    private menuSelection;
+    private menuQuery;
+    private menuDismissed;
+    private escapeMenuTimer;
+    private standaloneMenuEscape;
+    private hideMenu;
+    private renderMenu;
+    private readonly onEnd;
+    private readonly onResize;
+    private finishSecret;
+    secret(prompt: string): Promise<string>;
+    private readonly onData;
+    private insert;
+    private readonly onKeypress;
+    rememberPrompt(prompt: string, literal?: boolean): void;
+    clearHistory(): void;
+    private interrupt;
+    get isClosed(): boolean;
+    question(prompt: string, completeCommands?: boolean): Promise<string>;
+    multiline(): Promise<string>;
+    close(): void;
+}

package/dist/cli/console/console-model-catalog.d.ts

@@ -0,0 +1,25 @@
+export declare const CONSOLE_MODEL_CATALOG: {
+    readonly sdkVersion: "1.25.1";
+    readonly providers: {
+        readonly openai: {
+            readonly revision: "2026-09-12";
+            readonly sourceSha256: "af33783afbf76d7fd12776a2a19244663c286a0f7bc6f05549e2ffe8a3e41900";
+            readonly models: readonly ["gpt-6-astra", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-4o-mini"];
+        };
+        readonly qwen: {
+            readonly revision: "2026-09-20";
+            readonly sourceSha256: "f52a311095ad69f94bdfdbb71f7011ec7e19d24a5c7d7a116f53d7d13c8c6008";
+            readonly models: readonly ["qwen3.8-omni-flash", "qwen3.8-max-0902", "qwen3.8-max", "qwen3.8-flash", "qwen3.8-max-preview", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-flash", "qwen3.5-omni-plus", "qwen-plus"];
+        };
+        readonly gemini: {
+            readonly revision: "2026-09-16";
+            readonly sourceSha256: "ef26943ffd54a786e06f232adf06585ccfdddb6450dd090b2e7bc01d668153b4";
+            readonly models: readonly ["gemini-3.8-flash", "gemini-3.7-flash", "gemini-3.6-flash", "gemini-3.5-flash-lite", "gemini-3.5-flash", "gemini-3.1-pro-preview", "gemini-3.1-pro-preview-customtools", "gemini-3-flash-preview", "gemini-3.1-flash-lite"];
+        };
+        readonly meta: {
+            readonly revision: "2026-09-04";
+            readonly sourceSha256: "0e655bb5cee4dd5430336bec10d1a9cfb08a4fdc5902c211d91599f6f92492f6";
+            readonly models: readonly ["muse-spark-1.3", "muse-spark-1.2", "muse-spark-1.2-contributor", "muse-spark-1.1"];
+        };
+    };
+};

package/dist/cli/console/console-navigation.d.ts

@@ -0,0 +1,27 @@
+import type { ConsoleInput } from "./console-input.js";
+import type { ProviderAvailability } from "../../providers/providers.js";
+export declare const consoleModelChoices: (provider: string, defaultModel: string, current?: string) => {
+    value: string;
+    label: string;
+    detail: string;
+}[];
+export type ConsoleNavigationResult = {
+    command: string;
+} | {
+    provider: string;
+    model: string;
+};
+export declare const navigateConsole: (input: Pick<ConsoleInput, "select" | "question">, options: {
+    entry: "menu" | "provider" | "model";
+    current: {
+        provider: string;
+        model: string;
+    };
+    providers: readonly ProviderAvailability[];
+    sessions: () => Promise<readonly {
+        value: string;
+        label: string;
+        detail?: string;
+    }[]>;
+    service?: boolean;
+}) => Promise<ConsoleNavigationResult | undefined>;

package/dist/cli/console/console-presentation.d.ts

@@ -0,0 +1,18 @@
+/** Bound presentation metadata without allowing paths/titles to control the terminal. */
+export declare const consoleLabel: (text: string, width: number) => string;
+export declare const formatComposer: (input: {
+    model: string;
+    title?: string;
+    status: string;
+    attachments?: number;
+    automaticApprovals?: boolean;
+}, columns?: number, color?: boolean) => string;
+export declare const CONSOLE_SHORTCUTS: string;
+export declare const chooseConsoleItem: <T>(title: string, items: readonly {
+    value: T;
+    label: string;
+    detail?: string;
+}[], io: {
+    write(text: string): void;
+    ask(prompt: string): Promise<string>;
+}) => Promise<T | undefined>;

package/dist/cli/console/console-welcome.d.ts

@@ -0,0 +1,13 @@
+export declare const ZHIVEX_TERMINAL_LOGO: string;
+export declare const formatConsoleWelcome: (input: {
+    version: string;
+    workspace: string;
+    sessionId?: string;
+    sessionTitle?: string;
+    provider?: string;
+    model?: string;
+    service?: boolean;
+}, options?: {
+    color?: boolean;
+    columns?: number;
+}) => string;

package/dist/cli/console.d.ts

@@ -0,0 +1,2 @@
+import { type CliOptions } from "./arguments.js";
+export declare const chat: (options: CliOptions) => Promise<void>;

package/dist/cli/doctor.d.ts

@@ -0,0 +1,50 @@
+import { providerAvailability, resolveHarnessConfig, type HarnessProvider } from "../runtime/config.js";
+import { type HarnessOciRuntimeAdapter } from "../execution/execution-environment.js";
+import { CLI_JSON_SCHEMA_VERSION } from "./cli-stream.js";
+export type DoctorCheckStatus = "pass" | "warn" | "fail";
+export interface DoctorCheck {
+    id: string;
+    status: DoctorCheckStatus;
+    message: string;
+    details: Record<string, boolean | number | string | readonly string[]>;
+}
+import { type CliOptions } from "./arguments.js";
+export interface DoctorReport {
+    schemaVersion: typeof CLI_JSON_SCHEMA_VERSION;
+    kind: "doctor";
+    ok: boolean;
+    harnessVersion: string;
+    configSchemaVersion: number;
+    configuration: {
+        provider: HarnessProvider;
+        model: string;
+        workspace: string;
+        stateDirectory: string;
+        storeBackend: string;
+        scope: ReturnType<typeof resolveHarnessConfig>["scope"];
+        maxSteps: number;
+        timeoutMs: number;
+        agentProfile: "strict" | "repair";
+        budget: ReturnType<typeof resolveHarnessConfig>["budget"];
+        costBudget?: ReturnType<typeof resolveHarnessConfig>["costBudget"];
+        compaction: ReturnType<typeof resolveHarnessConfig>["compaction"];
+        allowedChecks: readonly string[];
+        requiredCapabilities: ReturnType<typeof resolveHarnessConfig>["requiredCapabilities"];
+        orchestration: ReturnType<typeof resolveHarnessConfig>["orchestration"];
+        context: ReturnType<typeof resolveHarnessConfig>["context"];
+        execution: ReturnType<typeof resolveHarnessConfig>["execution"];
+        mcpConfigPath?: string;
+    };
+    checks: DoctorCheck[];
+    providers: ReturnType<typeof providerAvailability>;
+}
+export interface DoctorContext {
+    env?: NodeJS.ProcessEnv;
+    nodeVersion?: string;
+    /** @deprecated Test-only compatibility injection for the secondary Bun runtime. */
+    bunVersion?: string;
+    ociRuntimeAdapter?: HarnessOciRuntimeAdapter;
+}
+export declare const createDoctorReport: (options?: Pick<CliOptions, "provider" | "model" | "workspace" | "stateDirectory" | "storeBackend" | "tenantId" | "userId" | "namespace" | "maxSteps" | "agentProfile" | "timeoutMs" | "maxToolCalls" | "maxToolErrors" | "maxInputTokens" | "maxOutputTokens" | "maxTotalTokens" | "maxCostUsd" | "inputCostPerMillion" | "outputCostPerMillion" | "allowedChecks" | "requiredCapabilities" | "subagentProfiles" | "subagentMaxSteps" | "subagentMaxToolCalls" | "subagentMaxToolErrors" | "subagentMaxInputTokens" | "subagentMaxOutputTokens" | "subagentMaxTotalTokens" | "subagentTimeoutMs" | "maxParallelReviews" | "executionBackend" | "ociRuntime" | "ociImage" | "ociAllowedCommands" | "ociShellMode" | "ociMaxProcessRuntimeMs" | "ociMaxProcessOutputBytes" | "ociMaxMemoryMb" | "ociMaxPids" | "ociMaxCpus" | "ociMaxWorkspaceBytes" | "ociMaxFileWriteBytes" | "ociTmpfsMb" | "mcpConfigPath" | "contextConfigPath" | "projectContext">, context?: DoctorContext) => Promise<DoctorReport>;
+export declare const formatDoctorReport: (report: DoctorReport) => string;
+export declare const doctor: (options: CliOptions) => Promise<void>;

package/dist/cli/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const CLI_EXIT_CODES: {
+    readonly success: 0;
+    readonly runtimeError: 1;
+    readonly usageError: 2;
+    readonly doctorFailed: 3;
+};
+export declare const cliExitCodeForError: (error: unknown) => 1 | 2;

package/dist/cli/help-text.d.ts

@@ -0,0 +1,2 @@
+export declare const CLI_HELP_TEXT: string;
+export declare const CLI_FULL_HELP_TEXT: string;

package/dist/cli/presentation.d.ts

@@ -0,0 +1,23 @@
+import { TerminalMarkdown } from "./terminal/terminal-markdown.js";
+import { type AgentApprovalRequest, type AgentApprovalResponse, type AgentRunOutput, type AgentStreamEvent } from "@zhivex-ai/agents";
+import { type HarnessRunOptions, type ZhivexHarness } from "../runtime/harness.js";
+import { type AgentTelemetryObserver } from "@zhivex-ai/agents/ops";
+import { type CliOptions } from "./arguments.js";
+export declare const annotateCliStreamError: (error: unknown, lastSequence: number | undefined) => Error;
+export declare const cliStreamErrorSequence: (error: unknown) => number;
+export declare const terminalErrorMessage: (error: unknown) => string;
+export declare const summarizeApproval: (approval: AgentApprovalRequest) => string;
+export declare const approvalResponses: (approvals: readonly AgentApprovalRequest[], approve: boolean, reason: string) => AgentApprovalResponse[];
+export declare const terminalApprovalResolver: (automaticallyApprove: boolean, ask?: (question: string) => Promise<string>) => NonNullable<HarnessRunOptions["resolveApprovals"]>;
+export declare const printTerminalResult: (result: AgentRunOutput, harness: ZhivexHarness, output: Pick<CliOptions, "json" | "jsonl">, tracker: {
+    streamedText: boolean;
+    sequence?: number;
+    markdown?: TerminalMarkdown;
+}) => void;
+export declare const flushToolActivity: (tracker: object) => void | undefined;
+export declare const streamSink: (output: Pick<CliOptions, "json" | "jsonl">, tracker: {
+    streamedText: boolean;
+    sequence?: number;
+    markdown?: TerminalMarkdown;
+}, compact?: boolean) => (event: AgentStreamEvent) => Promise<void>;
+export declare const orchestrationObserver: (json: boolean) => AgentTelemetryObserver;

package/dist/cli/resume-metadata.d.ts

@@ -0,0 +1,12 @@
+import { type AgentRunInput, type AgentRunState } from "@zhivex-ai/agents";
+import { type HarnessConfig, type HarnessConfigInput, type HarnessSubagentProfile } from "../runtime/config.js";
+import { type HarnessModelRoute } from "../providers/routing.js";
+import { type CliOptions } from "./arguments.js";
+export declare const HARNESS_RESUME_METADATA_KEY: "zhivexHarnessResume";
+export declare const HARNESS_RESUME_METADATA_SCHEMA_VERSION: 1;
+export declare const harnessConfigInput: (config: HarnessConfig) => HarnessConfigInput;
+export declare const persistedCliOptions: (input: HarnessConfigInput | undefined) => Partial<CliOptions>;
+export declare const createHarnessResumeMetadata: (config: HarnessConfig, routes?: ReadonlyMap<HarnessSubagentProfile, HarnessModelRoute>) => NonNullable<AgentRunInput["metadata"]>;
+export declare const readHarnessResumeConfig: (state: Pick<AgentRunState, "metadata">) => HarnessConfigInput | undefined;
+export declare const readHarnessResumeRoutes: (state: Pick<AgentRunState, "metadata">) => Map<"explorer" | "implementer" | "reviewer" | "tester", HarnessModelRoute>;
+export declare const resumeCommand: (runId: string, config: HarnessConfig, approve?: boolean) => string;

package/dist/cli/routing.d.ts

@@ -0,0 +1,6 @@
+import { type HarnessConfig, type HarnessSubagentProfile } from "../runtime/config.js";
+import { type HarnessModelRoute } from "../providers/routing.js";
+import { type CliOptions } from "./arguments.js";
+export declare const resolvedRouting: (options: CliOptions) => Map<"explorer" | "implementer" | "reviewer" | "tester", HarnessModelRoute>;
+export declare const assertRoutePricingIsSafe: (routes: ReadonlyMap<HarnessSubagentProfile, HarnessModelRoute>, costBudget: HarnessConfig["costBudget"]) => void;
+export declare const withTemporaryHarnessProfiles: <T>(profiles: readonly HarnessSubagentProfile[], configure: (profiles: readonly HarnessSubagentProfile[]) => Promise<void>, operation: () => Promise<T>) => Promise<T>;

package/dist/cli/run-commands.d.ts

@@ -0,0 +1,4 @@
+import { type CliOptions } from "./arguments.js";
+export declare const runOnce: (options: CliOptions) => Promise<void>;
+export declare const reviewOnce: (options: CliOptions) => Promise<void>;
+export declare const resumeRun: (options: CliOptions) => Promise<void>;