@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/acp-cli.js

@@ -1,22 +1,31 @@
 #!/usr/bin/env node
-import"./index-41fkzt91.js";
+import"./index-4jw3tvy8.js";
 import {
   CLI_OPTION_DEFINITIONS,
   parseHarnessModelRoute,
   resolveHarnessModelRoutes,
   validateCliCommandOptions
-} from "./index-f4sb0e2q.js";
+} from "./index-2jrdcj6b.js";
+import {
+  serveAcpStdio
+} from "./index-3ah1f369.js";
 import {
   createHarness,
   createHarnessClientAdapter
-} from "./index-5wjwe91x.js";
+} from "./index-hnaxfpb5.js";
+import"./index-h0mqx2ed.js";
+import"./index-8zzhggxv.js";
+import {
+  usagePricingSchema
+} from "./index-42gp2hy8.js";
+import"./index-azmwjp95.js";
+import"./index-z0qxmkm2.js";
 import {
   FileChangedWhileReadingError,
   FileSizeLimitError,
   UnsafeFileTypeError,
-  readRegularFileNoFollow,
-  usagePricingSchema
-} from "./index-pgqz45fj.js";
+  readRegularFileNoFollow
+} from "./index-yb239ghk.js";
 import {
   HARNESS_REQUIRED_CAPABILITIES,
   HARNESS_SUBAGENT_PROFILES,
@@ -28,11 +37,10 @@ import {
   providerDescriptor,
   reasoningEffortSchema,
   resolveHarnessConfig
-} from "./index-fvca1xea.js";
-import"./index-2aymdsqc.js";
-import {
-  serveAcpStdio
-} from "./index-77h9qr5h.js";
+} from "./index-gq9xagx2.js";
+import"./index-8705zxpr.js";
+import"./index-xqxeypt5.js";
+import"./index-qfpz5y2v.js";
 import {
   __require
 } from "./index-1bx83sw4.js";
@@ -43,11 +51,22 @@ import { fileURLToPath } from "node:url";
 
 // src/cli/cli-help.ts
 var usage = {
+  "checkpoints:storage": "zhx checkpoints storage",
+  "checkpoints:prune-review": "zhx checkpoints prune-review <checkpoint:id|restore:id> [...]",
+  "checkpoints:prune-apply": "zhx checkpoints prune-apply <reviewedPlanId> <checkpoint:id|restore:id> [...]",
+  "checkpoints:list": "zhx checkpoints list <sessionId>",
+  "checkpoints:capture": "zhx checkpoints capture <sessionId> <turnId> <path> [paths...]",
+  "checkpoints:inspect": "zhx checkpoints inspect <checkpointId>",
+  "checkpoints:prepare": "zhx checkpoints prepare <checkpointId>",
+  "checkpoints:review": "zhx checkpoints review <operationId>",
+  "checkpoints:apply": "zhx checkpoints apply <operationId> <reviewedProposalId>",
+  "checkpoints:recover": "zhx checkpoints recover <operationId> <existingForkSessionId>",
   init: "zhx init [--provider <id>] [--model <id>] [--profile <name>] [--update]",
   run: 'zhx run [options] "task" | zhx run [options] -',
   review: 'zhx review [options] "review task" | zhx review [options] -',
   chat: "zhx [--continue | --session <id>]",
   providers: "zhx providers [--json]",
+  policy: "zhx policy [options] [--json]",
   doctor: "zhx doctor [options]",
   resume: "zhx resume <runId> --approve|--deny",
   "runs:list": "zhx runs list [options]",
@@ -55,6 +74,7 @@ var usage = {
   "runs:cancel": "zhx runs cancel <runId> [options]",
   "runs:cleanup": "zhx runs cleanup --before <date> [options]",
   "runs:export": "zhx runs export <runId>",
+  "runs:report": "zhx runs report <runId> [envelope.json] [--session <sessionId>] [--json]",
   "sessions:list": "zhx sessions list [--search <text>]",
   "sessions:inspect": "zhx sessions inspect <sessionId>",
   "sessions:rename": 'zhx sessions rename <sessionId> "title"',
@@ -197,8 +217,8 @@ var applyCliProfile = async (options, context = {}) => {
 };
 
 // src/cli/arguments.ts
-var CLI_COMMANDS = ["init", "run", "review", "chat", "providers", "doctor", "resume", "runs", "sessions", "changes", "state", "help", "version"];
-var CLI_RUNS_COMMANDS = ["list", "inspect", "cancel", "cleanup", "export"];
+var CLI_COMMANDS = ["init", "run", "review", "chat", "providers", "doctor", "policy", "resume", "runs", "sessions", "checkpoints", "changes", "state", "help", "version"];
+var CLI_RUNS_COMMANDS = ["list", "inspect", "cancel", "cleanup", "export", "report"];
 var CLI_SESSIONS_COMMANDS = ["list", "inspect", "rename", "fork", "archive"];
 var CLI_CHANGES_COMMANDS = ["create", "verify"];
 var CLI_STATE_COMMANDS = ["status", "export", "import"];
@@ -269,7 +289,7 @@ var parseCliArgs = (argv) => {
         words.push(arg);
     }
     const first = words[0];
-    const parts = first === "help" ? words.slice(1) : first && COMMANDS.has(first) ? words.slice(0, ["runs", "sessions", "changes", "state"].includes(first) ? 2 : 1) : [];
+    const parts = first === "help" ? words.slice(1) : first && COMMANDS.has(first) ? words.slice(0, ["runs", "sessions", "checkpoints", "changes", "state"].includes(first) ? 2 : 1) : [];
     try {
       const topic = resolveHelpTopic(parts, parts.length > 0);
       return { ...options, command: "help", ...topic ? { helpTopic: topic } : {} };
@@ -354,6 +374,10 @@ var parseCliArgs = (argv) => {
         options.mcpConfigPath = optionValue(argv, index, argument);
         index += 1;
         break;
+      case "--tool-policy":
+        options.toolPolicyFile = optionValue(argv, index, argument);
+        index += 1;
+        break;
       case "--context-config":
         options.contextConfigPath = optionValue(argv, index, argument);
         index += 1;
@@ -758,16 +782,18 @@ var parseCliArgs = (argv) => {
   } else if (options.command === "runs") {
     const runsCommand = positional.shift();
     if (!runsCommand || !RUNS_COMMANDS.has(runsCommand)) {
-      throw new CliUsageError("runs requires one of: list, inspect, cancel, cleanup, export.");
+      throw new CliUsageError("runs requires one of: list, inspect, cancel, cleanup, export, report.");
     }
     options.runsCommand = runsCommand;
-    if (runsCommand === "inspect" || runsCommand === "cancel" || runsCommand === "export") {
+    if (runsCommand === "inspect" || runsCommand === "cancel" || runsCommand === "export" || runsCommand === "report") {
       const runId = positional.shift();
       if (!runId) {
         throw new CliUsageError(`runs ${runsCommand} requires a runId.`);
       }
       options.runId = runId;
     }
+    if (runsCommand === "report" && positional.length)
+      options.reportEnvelopePath = positional.shift();
     if (positional.length > 0) {
       throw new CliUsageError(`runs ${runsCommand} received unexpected positional arguments.`);
     }
@@ -793,6 +819,16 @@ var parseCliArgs = (argv) => {
     if (positional.length > 0) {
       throw new CliUsageError(`sessions ${sessionsCommand} received unexpected positional arguments.`);
     }
+  } else if (options.command === "checkpoints") {
+    const command2 = positional.shift();
+    const counts = { list: [1, 1], capture: [3, 22], inspect: [1, 1], prepare: [1, 1], review: [1, 1], apply: [2, 2], recover: [2, 2], storage: [0, 0], "prune-review": [1, 100], "prune-apply": [2, 101] };
+    if (!command2 || !Object.hasOwn(counts, command2))
+      throw new CliUsageError("checkpoints requires list, capture, inspect, prepare, review, apply, recover, storage, prune-review or prune-apply.");
+    const [min, max] = counts[command2];
+    if (positional.length < min || positional.length > max)
+      throw new CliUsageError(`Invalid arguments for checkpoints ${command2}; use --help.`);
+    options.checkpointsCommand = command2;
+    options.checkpointArguments = positional.splice(0);
   } else if (options.command === "changes") {
     const changesCommand = positional.shift();
     if (!changesCommand || !CHANGES_COMMANDS.has(changesCommand)) {
@@ -846,7 +882,7 @@ var parseCliArgs = (argv) => {
   } else if (["run", "resume"].includes(options.command) && optionCounts.has("--session")) {
     throw new CliUsageError("--session for run/resume requires --service.");
   }
-  const commandKey = options.command === "runs" ? `runs:${options.runsCommand}` : options.command === "sessions" ? `sessions:${options.sessionsCommand}` : options.command === "changes" ? `changes:${options.changesCommand}` : options.command === "state" ? `state:${options.stateCommand}` : options.command;
+  const commandKey = options.command === "checkpoints" ? `checkpoints:${options.checkpointsCommand}` : options.command === "runs" ? `runs:${options.runsCommand}` : options.command === "sessions" ? `sessions:${options.sessionsCommand}` : options.command === "changes" ? `changes:${options.changesCommand}` : options.command === "state" ? `state:${options.stateCommand}` : options.command;
   try {
     validateCliCommandOptions(commandKey, optionCounts);
   } catch (error) {
@@ -863,7 +899,7 @@ var parseCliArgs = (argv) => {
 
 // src/cli/cli-credentials.ts
 async function credentialModel(config, env, modelFactory) {
-  const { createProviderModel: createProviderModel2 } = await import("./config-6gtpxvjv.js");
+  const { createProviderModel: createProviderModel2 } = await import("./config-j3jga5wh.js");
   const { wrapLanguageModel } = await import("@zhivex-ai/core");
   const secrets = providerDescriptor(config.provider).credentialNames.map((name) => env[name]).filter((value) => !!value);
   const safeError = (error) => {

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

@@ -3,6 +3,17 @@ 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;
+export declare const approvalProvenanceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    origin: z.ZodEnum<{
+        application: "application";
+        automatic: "automatic";
+        interactive: "interactive";
+        unknown: "unknown";
+    }>;
+    channel: z.ZodString;
+    policyDigest: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
 declare const rowSchema: z.ZodObject<{
     approvalId: z.ZodString;
     digest: z.ZodString;
@@ -12,6 +23,17 @@ declare const rowSchema: z.ZodObject<{
     approved: z.ZodBoolean;
     decidedAt: z.ZodNumber;
     reviewedRevision: z.ZodNumber;
+    provenance: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        origin: z.ZodEnum<{
+            application: "application";
+            automatic: "automatic";
+            interactive: "interactive";
+            unknown: "unknown";
+        }>;
+        channel: z.ZodString;
+        policyDigest: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ApprovalDecisionRecord = z.infer<typeof rowSchema>;
 export interface ApprovalDecisionView extends ApprovalDecisionRecord {

package/dist/approvals/explicit-review.d.ts

@@ -0,0 +1,24 @@
+import type { AgentApprovalResponse, AgentRunState } from '@zhivex-ai/core';
+import type { AgentRunStore } from '@zhivex-ai/agents/ops';
+type DecisionOrigin = 'interactive' | 'automatic' | 'application';
+/** Presence only; admission still validates and consumes the receipt against durable state. */
+export declare const hasHostApprovalReceipt: (responses: readonly AgentApprovalResponse[]) => boolean;
+/** Trusted host only: call after its review UI confirms the complete snapshot.
+ * No renderer/client flag creates evidence. Cloning or serializing loses authority.
+ * This attests a local channel, not a person's legal or corporate identity. */
+export declare const issueExplicitReviewResponses: (host: object, state: AgentRunState, responses: readonly AgentApprovalResponse[], channel: string, now?: number, reviewedRevision?: number) => AgentApprovalResponse[];
+/** Observed provenance is separate from evidence of complete explicit review. */
+export declare const issueObservedApprovalResponses: (host: object, state: AgentRunState, responses: readonly AgentApprovalResponse[], channel: string, origins: readonly DecisionOrigin[], now?: number) => AgentApprovalResponse[];
+export declare const issueAutomaticApprovalResponses: (host: object, state: AgentRunState, responses: readonly AgentApprovalResponse[], channel: string) => AgentApprovalResponse[];
+/** Internal adapter handoff after its durable intent write; not a protocol field. */
+export declare const issueRecordedApprovalResponses: (host: object, state: AgentRunState, responses: readonly AgentApprovalResponse[]) => AgentApprovalResponse[];
+export declare const consumeExplicitReviewResponses: (host: object, state: AgentRunState, responses: readonly AgentApprovalResponse[], now?: number) => {
+    alreadyRecorded?: boolean;
+    origins: DecisionOrigin[];
+    channel: string;
+    policyDigest: string | null;
+    reviewedRevision: number;
+};
+/** Save review intent before effects; acknowledgement loss does not authorize retry. */
+export declare const admitExplicitReviewResponses: (host: object, store: AgentRunStore, state: AgentRunState, responses: readonly AgentApprovalResponse[]) => Promise<AgentRunState>;
+export {};

package/dist/approvals/host-policy-identity.d.ts

@@ -0,0 +1,3 @@
+export declare const bindHostPolicyIdentity: (host: object, digest: string, explicitReview?: boolean) => void;
+export declare const hostPolicyIdentity: (host: object) => string | null;
+export declare const requiresExplicitHostReview: (host: object) => boolean;

package/dist/cli/arguments.d.ts

@@ -2,8 +2,8 @@ import { type HarnessReasoningEffort } from "../providers/reasoning.js";
 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_COMMANDS: readonly ["init", "run", "review", "chat", "providers", "doctor", "policy", "resume", "runs", "sessions", "checkpoints", "changes", "state", "help", "version"];
+export declare const CLI_RUNS_COMMANDS: readonly ["list", "inspect", "cancel", "cleanup", "export", "report"];
 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"];
@@ -75,7 +75,10 @@ export interface CliOptions {
     runId?: string;
     idempotencyKey?: string;
     runsCommand?: RunsCommand;
+    reportEnvelopePath?: string;
     sessionsCommand?: SessionsCommand;
+    checkpointsCommand?: "list" | "capture" | "inspect" | "prepare" | "review" | "apply" | "recover" | "storage" | "prune-review" | "prune-apply";
+    checkpointArguments?: string[];
     changesCommand?: ChangesCommand;
     stateCommand?: StateCommand;
     artifactPath?: string;
@@ -87,6 +90,7 @@ export interface CliOptions {
     sessionTitle?: string;
     sessionSearch?: string;
     pricingFile?: string;
+    toolPolicyFile?: string;
     usageLimitUsd?: number;
     continueSession: boolean;
     implicitCommand: boolean;

package/dist/cli/checkpoints.d.ts

@@ -0,0 +1,230 @@
+import { type CliSession } from '../persistence/sessions.js';
+import { type CliOptions } from './arguments.js';
+/** Operator CLI over the existing checkpoint API; never constructs a model. */
+export declare function checkpointCliDocument(options: CliOptions): Promise<{
+    policy: 'explicit-reviewed-removal';
+    automaticEviction: false;
+    maxRecords: number;
+    maxRecordBytes: number;
+    maxFilesPerCheckpoint: number;
+    maxFileBytes: number;
+    records: number;
+    availableRecords: number;
+    serializedBytes: number;
+    pendingRestores: number;
+    checkpoints: {
+        id: string;
+        referenced: boolean;
+    }[];
+    kind: string;
+    restores?: never;
+    inspection?: never;
+    reviewedProposalId?: never;
+    diff?: never;
+    coverage?: never;
+    forkSessionId?: never;
+    operationId?: never;
+    stage?: never;
+    session?: never;
+} | {
+    planId: string;
+    selection: {
+        checkpointIds: string[];
+        completedRestoreIds: string[];
+    };
+    records: {
+        id: string;
+        kind: string;
+        sessionId: string;
+        bytes: number;
+    }[];
+    recordsBefore: number;
+    recordsAfter: number;
+    bytesRemoved: number;
+    workspaceFilesChanged: false;
+    conversationsChanged: false;
+    kind: string;
+    checkpoints?: never;
+    restores?: never;
+    inspection?: never;
+    reviewedProposalId?: never;
+    diff?: never;
+    coverage?: never;
+    forkSessionId?: never;
+    operationId?: never;
+    stage?: never;
+    session?: never;
+} | {
+    kind: string;
+    checkpoints: {
+        id: string;
+        sessionId: string;
+        turnId: string;
+        files: {
+            path: string;
+            digest: string;
+            bytes: number;
+            mode: number;
+        }[];
+    }[];
+    restores: {
+        id: string;
+        checkpointId: string;
+        proposalId: string;
+        stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+        forkSessionId?: string;
+    }[];
+    inspection?: never;
+    reviewedProposalId?: never;
+    diff?: never;
+    coverage?: never;
+    forkSessionId?: never;
+    operationId?: never;
+    stage?: never;
+    session?: never;
+} | {
+    checkpoints?: never;
+    restores?: never;
+    kind: string;
+    inspection: {
+        checkpoint: {
+            id: string;
+            sessionId: string;
+            turnId: string;
+            files: {
+                path: string;
+                digest: string;
+                bytes: number;
+                mode: number;
+            }[];
+        };
+        files: ({
+            path: string;
+            status: "mode-conflict";
+            before?: never;
+            after?: never;
+            expectedDigest?: never;
+            afterDigest?: never;
+            mode?: never;
+        } | {
+            path: string;
+            status: "available";
+            before: string;
+            after: string;
+            expectedDigest: string;
+            afterDigest: string;
+            mode: number;
+        } | {
+            before?: never;
+            after?: never;
+            expectedDigest?: never;
+            afterDigest?: never;
+            mode?: never;
+            path: string;
+            status: "unavailable";
+        })[];
+        coverage: {
+            existingTextOnly: true;
+            maxFiles: number;
+            maxFileBytes: number;
+            creation: false;
+            deletion: false;
+            binary: false;
+            modeRollback: false;
+            fullWorkspaceSnapshot: false;
+        };
+    };
+    reviewedProposalId?: never;
+    diff?: never;
+    coverage?: never;
+    forkSessionId?: never;
+    operationId?: never;
+    stage?: never;
+    session?: never;
+} | {
+    checkpoints?: never;
+    restores?: never;
+    inspection?: never;
+    kind: string;
+    operationId: string;
+    stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+    reviewedProposalId: string;
+    diff: {
+        proposalId: string;
+        files: {
+            path: string;
+            expectedDigest: import("../index.js").FileDigest | null;
+            before: string | null;
+            after: string;
+            afterDigest: import("../index.js").FileDigest;
+        }[];
+    };
+    coverage: {
+        existingTextOnly: true;
+        maxFiles: number;
+        maxFileBytes: number;
+        creation: false;
+        deletion: false;
+        binary: false;
+        modeRollback: false;
+        fullWorkspaceSnapshot: false;
+    };
+    forkSessionId?: never;
+    session?: never;
+} | {
+    checkpoints?: never;
+    restores?: never;
+    inspection?: never;
+    kind: string;
+    operationId: string;
+    stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+    reviewedProposalId: string;
+    forkSessionId: string | undefined;
+    previewStatus: string;
+    diff?: {
+        proposalId: string;
+        files: {
+            path: string;
+            expectedDigest: import("../index.js").FileDigest | null;
+            before: string | null;
+            after: string;
+            afterDigest: import("../index.js").FileDigest;
+        }[];
+    };
+    coverage: {
+        existingTextOnly: true;
+        maxFiles: number;
+        maxFileBytes: number;
+        creation: false;
+        deletion: false;
+        binary: false;
+        modeRollback: false;
+        fullWorkspaceSnapshot: false;
+    };
+    session?: never;
+} | {
+    checkpoints?: never;
+    restores?: never;
+    inspection?: never;
+    reviewedProposalId?: never;
+    diff?: never;
+    coverage?: never;
+    kind: string;
+    operationId: string;
+    stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+    forkSessionId: string | undefined;
+    session?: never;
+} | {
+    checkpoints?: never;
+    restores?: never;
+    inspection?: never;
+    reviewedProposalId?: never;
+    diff?: never;
+    coverage?: never;
+    forkSessionId?: never;
+    kind: string;
+    operationId: string;
+    stage: "applied" | "applying" | "completed" | "forked" | "forking" | "prepared";
+    session: CliSession;
+}>;
+export declare function manageCheckpoints(options: CliOptions): Promise<CliSession | undefined>;

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

@@ -7,10 +7,12 @@ export declare const MAX_CLI_PROFILE_BYTES: number;
 export declare const cliProfileSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     provider: z.ZodEnum<{
+        anthropic: "anthropic";
         gemini: "gemini";
         meta: "meta";
         openai: "openai";
         qwen: "qwen";
+        vertex: "vertex";
     }>;
     reasoningEffort: z.ZodOptional<z.ZodEnum<{
         default: "default";
@@ -42,7 +44,7 @@ export declare const createCliProfile: (name: string, input: {
     path: string;
     profile: {
         schemaVersion: 1;
-        provider: "gemini" | "meta" | "openai" | "qwen";
+        provider: "anthropic" | "gemini" | "meta" | "openai" | "qwen" | "vertex";
         reasoningEffort?: "default" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
         model: string;
     };
@@ -56,7 +58,7 @@ export declare const updateCliProfile: (name: string, input: {
     path: string;
     profile: {
         schemaVersion: 1;
-        provider: "gemini" | "meta" | "openai" | "qwen";
+        provider: "anthropic" | "gemini" | "meta" | "openai" | "qwen" | "vertex";
         reasoningEffort?: "default" | "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
         model: string;
     };

package/dist/cli/governance-report.d.ts

@@ -0,0 +1,5 @@
+import type { AgentRunStore } from '@zhivex-ai/core';
+import type { HarnessConfig } from '../runtime/config.js';
+import type { CliOptions } from './arguments.js';
+/** Provider-free report command; the optional envelope is bounded data, never a command. */
+export declare function governanceReportCli(options: CliOptions, config: HarnessConfig, store: AgentRunStore): Promise<string>;

package/dist/cli/policy-decisions.d.ts

@@ -0,0 +1,9 @@
+import { type HarnessPolicyDecisionEvent, type PolicyDecisionEvidence } from '../runtime/policy-decisions.js';
+export declare const formatPolicyDecision: (event: HarnessPolicyDecisionEvent) => string;
+export declare function observeCliPolicy<T>(options: {
+    json?: boolean;
+    jsonl?: boolean;
+}, tracker: {
+    sequence?: number;
+    policyEvidence?: PolicyDecisionEvidence;
+}, work: () => Promise<T>): Promise<T>;

package/dist/cli/policy.d.ts

@@ -0,0 +1,5 @@
+import { type HarnessPolicyInspection } from '../runtime/policy-inspection.js';
+import type { CliOptions } from './arguments.js';
+export declare function formatPolicyInspection(policy: HarnessPolicyInspection): string;
+export declare function printPolicyInspection(policy: HarnessPolicyInspection, json: boolean | undefined): void;
+export declare function inspectCliPolicy(options: CliOptions): Promise<void>;

package/dist/cli/presentation.d.ts

@@ -1,3 +1,4 @@
+import type { PolicyDecisionEvidence } from "../runtime/policy-decisions.js";
 import type { ActivityHistory } from "./terminal/activity-history.js";
 import { TerminalMarkdown } from "./terminal/terminal-markdown.js";
 import { type AgentApprovalRequest, type AgentApprovalResponse, type AgentRunOutput, type AgentStreamEvent } from "@zhivex-ai/agents";
@@ -13,11 +14,12 @@ export declare const terminalApprovalResolver: (automaticallyApprove: boolean |
     select: import("./cli-credentials.js").CredentialInput["select"];
     workspace: string;
     sessionGrants?: Set<string>;
-}) => NonNullable<HarnessRunOptions["resolveApprovals"]>;
+}, reviewHost?: ZhivexHarness) => NonNullable<HarnessRunOptions["resolveApprovals"]>;
 export declare const printTerminalResult: (result: AgentRunOutput, harness: ZhivexHarness, output: Pick<CliOptions, "json" | "jsonl">, tracker: {
     streamedText: boolean;
     sequence?: number;
     markdown?: TerminalMarkdown;
+    policyEvidence?: PolicyDecisionEvidence;
 }) => void;
 export declare const flushToolActivity: (tracker: object) => void | undefined;
 export declare const streamSink: (output: Pick<CliOptions, "json" | "jsonl">, tracker: {

package/dist/cli/terminal/terminal-ui.d.ts

@@ -25,6 +25,10 @@ export interface TerminalApprovalResolverOptions {
     maxSummaryCharacters?: number;
     approvedReason?: string;
     deniedReason?: string;
+    /** Host policy: complete bounded payload, no cached session grants. */
+    requireCompleteReview?: boolean;
+    /** Host-only observation; never determines approval or grants explicit review. */
+    onDecisionOrigin?: (origin: 'interactive' | 'automatic') => void;
 }
 /**
  * Resolve approvals one at a time. Returning undefined deliberately leaves the