@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/{service-client-cli-yx56n0hc.js → service-client-cli-kns4mf57.js}

@@ -8,13 +8,16 @@ import {
   formatAppliedFiles,
   formatConsoleHelp,
   formatConsoleWelcome,
+  formatPolicyDecision,
+  harnessPolicyDecisionEventSchema,
   navigateConsole,
+  printPolicyInspection,
   sanitizeTerminalText,
   serializeStreamResult
-} from "./cli-entry-c2f58zj2.js";
+} from "./cli-entry-ae7x44d4.js";
 import {
   HARNESS_VERSION
-} from "./cli-entry-64pdp3k5.js";
+} from "./cli-entry-ev76ezcd.js";
 import {
   HARNESS_ERROR_CODES,
   HARNESS_ERROR_SCHEMA_VERSION,
@@ -22,7 +25,7 @@ import {
   HarnessStateConflictError,
   PROVIDERS,
   reasoningEffortSchema
-} from "./cli-entry-427869g9.js";
+} from "./cli-entry-d5788aay.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -35,7 +38,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { createServer, request as httpRequest } from "node:http";
 import { mkdir, lstat, realpath, open, unlink, chmod } from "node:fs/promises";
 import path from "node:path";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/client/protocol.ts
 import { z } from "zod";
@@ -46,12 +49,36 @@ var scoped = { projectId: id };
 var session = { ...scoped, sessionId: id };
 var run = { ...session, runId: id };
 var mutation = { idempotencyKey: id };
+var checkpoint = { ...session, checkpointId: z.string().uuid() };
+var restore = { ...session, operationId: z.string().uuid() };
+var fileDigest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
 var harnessClientCommandSchema = z.discriminatedUnion("method", [
   z.object({ method: z.literal("project.get"), ...scoped }).strict(),
+  z.object({ method: z.literal("policy.get"), ...scoped }).strict(),
   z.object({ method: z.literal("session.list"), ...scoped, search: z.string().max(256).optional() }).strict(),
   z.object({ method: z.literal("session.create"), ...scoped, ...mutation, title: z.string().max(256).optional() }).strict(),
   z.object({ method: z.literal("session.get"), ...session }).strict(),
   z.object({ method: z.literal("session.rename"), ...session, ...mutation, expectedRevision: revision, title: z.string().max(256) }).strict(),
+  z.object({ method: z.literal("checkpoint.list"), ...session }).strict(),
+  z.object({ method: z.literal("checkpoint.inspect"), ...checkpoint }).strict(),
+  z.object({
+    method: z.literal("checkpoint.capture"),
+    ...session,
+    ...mutation,
+    expectedRevision: revision,
+    turnId: id,
+    paths: z.array(z.string().min(1).max(1024)).min(1).max(20)
+  }).strict(),
+  z.object({
+    method: z.literal("restore.prepare"),
+    ...checkpoint,
+    ...mutation,
+    expectedRevision: revision,
+    expected: z.record(z.string().min(1).max(1024), fileDigest).refine((value) => Object.keys(value).length >= 1 && Object.keys(value).length <= 20)
+  }).strict(),
+  z.object({ method: z.literal("restore.get"), ...restore }).strict(),
+  z.object({ method: z.literal("restore.apply"), ...restore, ...mutation, expectedRevision: revision, reviewedProposalId: fileDigest }).strict(),
+  z.object({ method: z.literal("restore.recoverFork"), ...restore, ...mutation, expectedRevision: revision, forkSessionId: id }).strict(),
   z.object({ method: z.literal("run.start"), ...session, ...mutation, expectedRevision: revision, prompt: z.string().min(1).max(64 * 1024) }).strict(),
   z.object({ method: z.literal("run.get"), ...run, includeReview: z.boolean().optional(), includeDiff: z.boolean().optional(), decisionOffset: z.number().int().min(0).max(512).optional() }).strict(),
   z.object({
@@ -70,26 +97,19 @@ var harnessClientRequestSchema = z.object({
   command: harnessClientCommandSchema
 }).strict();
 
-// src/approvals/approval-history.ts
-import { z as z2 } from "zod";
-var rowSchema = z2.object({ approvalId: z2.string().max(256), digest: z2.string().regex(/^[a-f0-9]{64}$/), toolCallId: z2.string().max(256).optional(), name: z2.string().max(256), inputDigest: z2.string().regex(/^[a-f0-9]{64}$/).optional(), approved: z2.boolean(), decidedAt: z2.number().int().nonnegative(), reviewedRevision: z2.number().int().nonnegative() }).strict();
-
 // src/approvals/approval-diff.ts
-import { z as z3 } from "zod";
-var sha = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
-var file = z3.object({ path: z3.string().max(1024), expectedDigest: sha.nullable(), before: z3.string().nullable(), after: z3.string().nullable(), afterDigest: sha.nullable(), beforeMode: z3.number().int().optional(), afterMode: z3.number().int().optional(), operation: z3.enum(["create", "update", "delete"]).optional() }).strict();
-var archive = z3.object({ approvalId: z3.string().max(256), digest: z3.string().regex(/^[a-f0-9]{64}$/), proposalId: sha, files: z3.array(file).min(1).max(50) }).strict();
-var archives = z3.array(archive).max(512);
+import { z as z2 } from "zod";
+var sha = z2.string().regex(/^sha256:[a-f0-9]{64}$/);
+var file = z2.object({ path: z2.string().max(1024), expectedDigest: sha.nullable(), before: z2.string().nullable(), after: z2.string().nullable(), afterDigest: sha.nullable(), beforeMode: z2.number().int().optional(), afterMode: z2.number().int().optional(), operation: z2.enum(["create", "update", "delete"]).optional() }).strict();
+var archive = z2.object({ approvalId: z2.string().max(256), digest: z2.string().regex(/^[a-f0-9]{64}$/), proposalId: sha, files: z2.array(file).min(1).max(50) }).strict();
+var archives = z2.array(archive).max(512);
 var maxBytes = 2 * 1024 * 1024;
 
 // src/approvals/approval-preview.ts
-import { z as z4 } from "zod";
-
-// src/client/service-events.ts
-import { createRedactionPolicy } from "@zhivex-ai/agents";
+import { z as z3 } from "zod";
 
 // src/client/local-service.ts
-var harnessLocalCredentialsSchema = z5.object({ schemaVersion: z5.literal(1), socketPath: z5.string().min(1), token: z5.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var harnessLocalCredentialsSchema = z4.object({ schemaVersion: z4.literal(1), socketPath: z4.string().min(1), token: z4.string().regex(/^[a-f0-9]{64}$/) }).strict();
 var readHarnessLocalCredentials = async (filename) => {
   const { constants } = await import("node:fs");
   const file2 = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
@@ -141,26 +161,26 @@ var requestHarnessLocalService = async (credentials, endpoint, payload) => {
 };
 
 // src/client/json-contracts.ts
-import { z as z6 } from "zod";
-var observationalDocument = (shape) => z6.object(shape).passthrough();
-var jsonBase = { schemaVersion: z6.literal(CLI_JSON_SCHEMA_VERSION) };
+import { z as z5 } from "zod";
+var observationalDocument = (shape) => z5.object(shape).passthrough();
+var jsonBase = { schemaVersion: z5.literal(CLI_JSON_SCHEMA_VERSION) };
 var eventBase = {
-  schemaVersion: z6.literal(CLI_EVENT_SCHEMA_VERSION),
-  sequence: z6.number().int().nonnegative()
+  schemaVersion: z5.literal(CLI_EVENT_SCHEMA_VERSION),
+  sequence: z5.number().int().nonnegative()
 };
-var nonnegativeInteger = z6.number().int().nonnegative();
-var digestSchema = z6.string().regex(/^sha256:[a-f0-9]{64}$/);
+var nonnegativeInteger = z5.number().int().nonnegative();
+var digestSchema = z5.string().regex(/^sha256:[a-f0-9]{64}$/);
 var jsonObjectSchema = observationalDocument({});
 var scopeSchema = observationalDocument({
-  tenantId: z6.string().min(1),
-  userId: z6.string().min(1).optional(),
-  namespace: z6.string().min(1).optional()
+  tenantId: z5.string().min(1),
+  userId: z5.string().min(1).optional(),
+  namespace: z5.string().min(1).optional()
 });
 var runIdentity = {
-  runId: z6.string().min(1),
-  status: z6.string().min(1),
-  provider: z6.string().min(1),
-  model: z6.string().min(1)
+  runId: z5.string().min(1),
+  status: z5.string().min(1),
+  provider: z5.string().min(1),
+  model: z5.string().min(1)
 };
 var runSummarySchema = observationalDocument({
   ...runIdentity,
@@ -176,24 +196,24 @@ var runSummarySchema = observationalDocument({
   updatedAt: nonnegativeInteger
 });
 var sessionRunSchema = observationalDocument({
-  turnId: z6.string().min(1),
+  turnId: z5.string().min(1),
   sequence: nonnegativeInteger,
-  runId: z6.string().min(1),
-  provider: z6.string().min(1),
-  model: z6.string().min(1),
-  status: z6.string().min(1),
+  runId: z5.string().min(1),
+  provider: z5.string().min(1),
+  model: z5.string().min(1),
+  status: z5.string().min(1),
   createdAt: nonnegativeInteger,
   updatedAt: nonnegativeInteger
 });
 var sessionSchema = observationalDocument({
-  schemaVersion: z6.literal(1),
-  sessionId: z6.string().min(1),
-  workspaceKey: z6.string().min(1),
-  scopeKey: z6.string().min(1),
+  schemaVersion: z5.literal(1),
+  sessionId: z5.string().min(1),
+  workspaceKey: z5.string().min(1),
+  scopeKey: z5.string().min(1),
   revision: nonnegativeInteger,
   createdAt: nonnegativeInteger,
   updatedAt: nonnegativeInteger,
-  runs: z6.array(sessionRunSchema)
+  runs: z5.array(sessionRunSchema)
 });
 var tokenUsageSchema = observationalDocument({
   inputTokens: nonnegativeInteger.optional(),
@@ -202,17 +222,17 @@ var tokenUsageSchema = observationalDocument({
   outputTokens: nonnegativeInteger.optional(),
   reasoningTokens: nonnegativeInteger.optional(),
   totalTokens: nonnegativeInteger.optional(),
-  speed: z6.enum(["standard", "fast"]).optional()
+  speed: z5.enum(["standard", "fast"]).optional()
 });
 var budgetConfigSchema = observationalDocument({
-  unlimitedTokens: z6.boolean().optional(),
+  unlimitedTokens: z5.boolean().optional(),
   maxSteps: nonnegativeInteger,
   maxToolCalls: nonnegativeInteger,
   maxToolErrors: nonnegativeInteger,
   maxInputTokens: nonnegativeInteger,
   maxOutputTokens: nonnegativeInteger,
   maxTotalTokens: nonnegativeInteger,
-  includeChildRuns: z6.boolean()
+  includeChildRuns: z5.boolean()
 });
 var budgetConsumptionSchema = observationalDocument({
   steps: nonnegativeInteger,
@@ -233,117 +253,117 @@ var budgetRemainingSchema = observationalDocument({
 var budgetStatusSchema = observationalDocument({
   consumption: budgetConsumptionSchema,
   remaining: budgetRemainingSchema,
-  includeChildRuns: z6.boolean()
+  includeChildRuns: z5.boolean()
 });
 var costEstimateSchema = observationalDocument({
-  inputCost: z6.number().nonnegative().optional(),
-  outputCost: z6.number().nonnegative().optional(),
-  totalCost: z6.number().nonnegative().optional(),
-  currency: z6.string().min(1).optional(),
+  inputCost: z5.number().nonnegative().optional(),
+  outputCost: z5.number().nonnegative().optional(),
+  totalCost: z5.number().nonnegative().optional(),
+  currency: z5.string().min(1).optional(),
   usage: tokenUsageSchema.optional()
 });
 var mutationAuditSchema = observationalDocument({
-  id: z6.string().min(1),
-  operation: z6.enum(["create", "update", "move", "quarantine", "restore"]),
-  path: z6.string().min(1),
-  destination: z6.string().min(1).optional(),
+  id: z5.string().min(1),
+  operation: z5.enum(["create", "update", "move", "quarantine", "restore"]),
+  path: z5.string().min(1),
+  destination: z5.string().min(1).optional(),
   beforeDigest: digestSchema.optional(),
   afterDigest: digestSchema.optional(),
-  timestamp: z6.iso.datetime(),
-  quarantineId: z6.string().min(1).optional()
+  timestamp: z5.iso.datetime(),
+  quarantineId: z5.string().min(1).optional()
 });
 var approvalSummarySchema = observationalDocument({
-  id: z6.string().min(1),
-  kind: z6.string().min(1),
-  name: z6.string().min(1),
-  arguments: z6.json(),
-  childRunId: z6.string().min(1).optional(),
-  childAgentId: z6.string().min(1).optional()
+  id: z5.string().min(1),
+  kind: z5.string().min(1),
+  name: z5.string().min(1),
+  arguments: z5.json(),
+  childRunId: z5.string().min(1).optional(),
+  childAgentId: z5.string().min(1).optional()
 });
 var childRunSummarySchema = observationalDocument({
-  runId: z6.string().min(1),
-  agentId: z6.string().min(1).optional(),
-  toolName: z6.string().min(1).optional(),
-  status: z6.string().min(1),
+  runId: z5.string().min(1),
+  agentId: z5.string().min(1).optional(),
+  toolName: z5.string().min(1).optional(),
+  status: z5.string().min(1),
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
   toolErrors: nonnegativeInteger,
   usage: tokenUsageSchema.optional()
 });
 var capabilityReportSchema = observationalDocument({
-  provider: z6.string().min(1),
-  model: z6.string().min(1),
-  supportTier: z6.string().min(1).optional(),
+  provider: z5.string().min(1),
+  model: z5.string().min(1),
+  supportTier: z5.string().min(1).optional(),
   capabilities: observationalDocument({
-    streaming: z6.boolean(),
-    tools: z6.boolean(),
-    "structured-output": z6.boolean(),
-    "parallel-tools": z6.boolean(),
-    reasoning: z6.boolean(),
-    "web-search": z6.boolean()
+    streaming: z5.boolean(),
+    tools: z5.boolean(),
+    "structured-output": z5.boolean(),
+    "parallel-tools": z5.boolean(),
+    reasoning: z5.boolean(),
+    "web-search": z5.boolean()
   })
 });
-var providerConfigurationSchema = z6.object({
-  customEndpoint: z6.boolean(),
-  endpointValid: z6.boolean(),
-  endpointSecure: z6.boolean()
-}).catchall(z6.boolean());
+var providerConfigurationSchema = z5.object({
+  customEndpoint: z5.boolean(),
+  endpointValid: z5.boolean(),
+  endpointSecure: z5.boolean()
+}).catchall(z5.boolean());
 var providerAvailabilitySchema = observationalDocument({
-  id: z6.string().min(1),
-  name: z6.string().min(1),
-  defaultModel: z6.string().min(1),
-  credentialNames: z6.array(z6.string().min(1)),
-  capabilities: z6.array(z6.enum(["streaming", "tool-calling", "approval-resume"])),
-  support: z6.enum(["certified", "provisional"]),
-  configured: z6.boolean(),
-  credentials: z6.array(observationalDocument({
-    name: z6.string().min(1),
-    present: z6.boolean()
+  id: z5.string().min(1),
+  name: z5.string().min(1),
+  defaultModel: z5.string().min(1),
+  credentialNames: z5.array(z5.string().min(1)),
+  capabilities: z5.array(z5.enum(["streaming", "tool-calling", "approval-resume"])),
+  support: z5.enum(["certified", "provisional"]),
+  configured: z5.boolean(),
+  credentials: z5.array(observationalDocument({
+    name: z5.string().min(1),
+    present: z5.boolean()
   })),
   configuration: providerConfigurationSchema
 });
 var orchestrationConfigSchema = observationalDocument({
-  profiles: z6.array(z6.enum(["explorer", "implementer", "tester", "reviewer"])),
+  profiles: z5.array(z5.enum(["explorer", "implementer", "tester", "reviewer"])),
   childBudget: budgetConfigSchema,
   childTimeoutMs: nonnegativeInteger,
   maxParallelReviews: nonnegativeInteger
 });
-var executionConfigSchema = z6.discriminatedUnion("backend", [
-  observationalDocument({ backend: z6.literal("none") }),
+var executionConfigSchema = z5.discriminatedUnion("backend", [
+  observationalDocument({ backend: z5.literal("none") }),
   observationalDocument({
-    backend: z6.literal("oci"),
-    policyVersion: z6.string().min(1),
-    runtime: z6.enum(["docker", "podman"]),
-    image: z6.string().min(1),
-    allowedCommands: z6.array(z6.string().min(1)),
-    shellMode: z6.enum(["deny", "ask"]),
+    backend: z5.literal("oci"),
+    policyVersion: z5.string().min(1),
+    runtime: z5.enum(["docker", "podman"]),
+    image: z5.string().min(1),
+    allowedCommands: z5.array(z5.string().min(1)),
+    shellMode: z5.enum(["deny", "ask"]),
     maxProcessRuntimeMs: nonnegativeInteger,
     maxProcessOutputBytes: nonnegativeInteger,
     maxMemoryMb: nonnegativeInteger,
     maxPids: nonnegativeInteger,
-    maxCpus: z6.number().positive(),
+    maxCpus: z5.number().positive(),
     maxWorkspaceBytes: nonnegativeInteger,
     maxFileWriteBytes: nonnegativeInteger,
     tmpfsMb: nonnegativeInteger
   })
 ]);
 var executionBindingSchema = observationalDocument({
-  environmentId: z6.string().min(1),
-  environmentVersion: z6.string().min(1).optional(),
-  fingerprint: z6.string().min(1),
-  workspaceId: z6.string().min(1).optional()
+  environmentId: z5.string().min(1),
+  environmentVersion: z5.string().min(1).optional(),
+  fingerprint: z5.string().min(1),
+  workspaceId: z5.string().min(1).optional()
 });
 var ociImageSchema = observationalDocument({
-  runtime: z6.enum(["docker", "podman"]),
-  runtimeVersion: z6.string().min(1),
-  imageReference: z6.string().min(1),
-  imageId: z6.string().min(1),
-  imageDigest: z6.string().min(1)
+  runtime: z5.enum(["docker", "podman"]),
+  runtimeVersion: z5.string().min(1),
+  imageReference: z5.string().min(1),
+  imageId: z5.string().min(1),
+  imageDigest: z5.string().min(1)
 });
-var runExecutionSchema = z6.discriminatedUnion("backend", [
-  observationalDocument({ backend: z6.literal("none") }),
+var runExecutionSchema = z5.discriminatedUnion("backend", [
+  observationalDocument({ backend: z5.literal("none") }),
   observationalDocument({
-    backend: z6.literal("oci"),
+    backend: z5.literal("oci"),
     binding: executionBindingSchema,
     image: ociImageSchema
   })
@@ -354,44 +374,44 @@ var migrationResultSchema = observationalDocument({
   migratedToolCalls: nonnegativeInteger
 });
 var runStoreSchema = observationalDocument({
-  backend: z6.enum(["sqlite", "file"]),
-  stateDirectory: z6.string().min(1),
+  backend: z5.enum(["sqlite", "file"]),
+  stateDirectory: z5.string().min(1),
   migration: migrationResultSchema.optional()
 });
 var doctorCheckSchema = observationalDocument({
-  id: z6.string().min(1),
-  status: z6.enum(["pass", "warn", "fail"]),
-  message: z6.string(),
-  details: z6.record(z6.string(), z6.union([
-    z6.boolean(),
-    z6.number(),
-    z6.string(),
-    z6.array(z6.string())
+  id: z5.string().min(1),
+  status: z5.enum(["pass", "warn", "fail"]),
+  message: z5.string(),
+  details: z5.record(z5.string(), z5.union([
+    z5.boolean(),
+    z5.number(),
+    z5.string(),
+    z5.array(z5.string())
   ]))
 });
 var doctorConfigurationSchema = observationalDocument({
-  requireVerifiedDelivery: z6.boolean().optional(),
-  provider: z6.string().min(1),
-  model: z6.string().min(1),
-  workspace: z6.string().min(1),
-  stateDirectory: z6.string().min(1),
-  storeBackend: z6.enum(["sqlite", "file"]),
+  requireVerifiedDelivery: z5.boolean().optional(),
+  provider: z5.string().min(1),
+  model: z5.string().min(1),
+  workspace: z5.string().min(1),
+  stateDirectory: z5.string().min(1),
+  storeBackend: z5.enum(["sqlite", "file"]),
   scope: scopeSchema,
   maxSteps: nonnegativeInteger,
   timeoutMs: nonnegativeInteger,
   budget: budgetConfigSchema,
   costBudget: observationalDocument({
-    maxCostUsd: z6.number().nonnegative(),
-    inputCostPer1kTokens: z6.number().nonnegative(),
-    outputCostPer1kTokens: z6.number().nonnegative()
+    maxCostUsd: z5.number().nonnegative(),
+    inputCostPer1kTokens: z5.number().nonnegative(),
+    outputCostPer1kTokens: z5.number().nonnegative()
   }).optional(),
   compaction: observationalDocument({
     maxMessages: nonnegativeInteger,
     maxEstimatedInputTokens: nonnegativeInteger,
     keepRecentMessages: nonnegativeInteger
   }),
-  allowedChecks: z6.array(z6.string().min(1)),
-  requiredCapabilities: z6.array(z6.enum([
+  allowedChecks: z5.array(z5.string().min(1)),
+  requiredCapabilities: z5.array(z5.enum([
     "streaming",
     "tools",
     "structured-output",
@@ -400,24 +420,24 @@ var doctorConfigurationSchema = observationalDocument({
     "web-search"
   ])),
   orchestration: orchestrationConfigSchema,
-  context: observationalDocument({ enabled: z6.boolean(), configPath: z6.string().min(1) }),
+  context: observationalDocument({ enabled: z5.boolean(), configPath: z5.string().min(1) }),
   execution: executionConfigSchema,
-  mcpConfigPath: z6.string().min(1).optional()
+  mcpConfigPath: z5.string().min(1).optional()
 });
 var cliRunResultDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("run-result"),
+  kind: z5.literal("run-result"),
   ...runIdentity,
-  output: z6.string(),
+  output: z5.string(),
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
-  mutations: z6.array(mutationAuditSchema),
-  pendingApprovals: z6.array(approvalSummarySchema),
-  children: z6.array(childRunSummarySchema),
+  mutations: z5.array(mutationAuditSchema),
+  pendingApprovals: z5.array(approvalSummarySchema),
+  children: z5.array(childRunSummarySchema),
   usage: tokenUsageSchema.optional(),
   budget: budgetStatusSchema,
   costBudget: observationalDocument({
-    limitUsd: z6.number().nonnegative(),
+    limitUsd: z5.number().nonnegative(),
     estimate: costEstimateSchema
   }).optional(),
   scope: scopeSchema,
@@ -425,65 +445,65 @@ var cliRunResultDocumentSchema = observationalDocument({
   orchestration: observationalDocument({
     profiles: orchestrationConfigSchema.shape.profiles,
     childBudget: budgetConfigSchema,
-    mcpServers: z6.array(z6.string().min(1))
+    mcpServers: z5.array(z5.string().min(1))
   }),
   execution: runExecutionSchema,
   store: runStoreSchema,
-  stateDirectory: z6.string()
+  stateDirectory: z5.string()
 });
 var cliProviderDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("providers"),
-  providers: z6.array(providerAvailabilitySchema)
+  kind: z5.literal("providers"),
+  providers: z5.array(providerAvailabilitySchema)
 });
 var cliInitDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("init"),
+  kind: z5.literal("init"),
   profile: observationalDocument({
-    name: z6.string().min(1),
-    path: z6.string().min(1),
+    name: z5.string().min(1),
+    path: z5.string().min(1),
     schemaVersion: nonnegativeInteger,
-    provider: z6.enum(PROVIDERS),
-    model: z6.string().min(1),
+    provider: z5.enum(PROVIDERS),
+    model: z5.string().min(1),
     reasoningEffort: reasoningEffortSchema.optional()
   }),
   credential: observationalDocument({
-    configured: z6.boolean(),
-    names: z6.array(z6.string().min(1))
+    configured: z5.boolean(),
+    names: z5.array(z5.string().min(1))
   }),
   next: observationalDocument({
-    doctor: z6.string().min(1),
-    run: z6.string().min(1)
+    doctor: z5.string().min(1),
+    run: z5.string().min(1)
   })
 });
 var cliDoctorDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("doctor"),
-  ok: z6.boolean(),
-  harnessVersion: z6.string().min(1),
+  kind: z5.literal("doctor"),
+  ok: z5.boolean(),
+  harnessVersion: z5.string().min(1),
   configSchemaVersion: nonnegativeInteger,
   configuration: doctorConfigurationSchema,
-  checks: z6.array(doctorCheckSchema),
-  providers: z6.array(providerAvailabilitySchema)
+  checks: z5.array(doctorCheckSchema),
+  providers: z5.array(providerAvailabilitySchema)
 });
 var cliReviewGroupDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("review-group"),
-  groupId: z6.string().min(1),
-  status: z6.enum(["completed", "failed"]),
-  profiles: z6.array(z6.string().min(1)).min(1),
-  outputs: z6.array(observationalDocument({
-    status: z6.enum(["fulfilled", "rejected"]),
-    name: z6.string().min(1).optional(),
-    agentId: z6.string().min(1).optional(),
-    runId: z6.string().min(1).optional(),
-    runStatus: z6.string().min(1).optional(),
-    output: z6.string().optional(),
+  kind: z5.literal("review-group"),
+  groupId: z5.string().min(1),
+  status: z5.enum(["completed", "failed"]),
+  profiles: z5.array(z5.string().min(1)).min(1),
+  outputs: z5.array(observationalDocument({
+    status: z5.enum(["fulfilled", "rejected"]),
+    name: z5.string().min(1).optional(),
+    agentId: z5.string().min(1).optional(),
+    runId: z5.string().min(1).optional(),
+    runStatus: z5.string().min(1).optional(),
+    output: z5.string().optional(),
     steps: nonnegativeInteger.optional(),
     usage: tokenUsageSchema.optional(),
     error: observationalDocument({
-      code: z6.enum(HARNESS_ERROR_CODES),
-      category: z6.enum([
+      code: z5.enum(HARNESS_ERROR_CODES),
+      category: z5.enum([
         "configuration",
         "usage",
         "workspace",
@@ -492,16 +512,16 @@ var cliReviewGroupDocumentSchema = observationalDocument({
         "approval",
         "execution"
       ]),
-      retryable: z6.boolean()
+      retryable: z5.boolean()
     }).optional()
   }))
 });
 var cliRunListDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("run-list"),
+  kind: z5.literal("run-list"),
   scope: scopeSchema,
-  backend: z6.string().min(1),
-  runs: z6.array(runSummarySchema)
+  backend: z5.string().min(1),
+  runs: z5.array(runSummarySchema)
 });
 var runInspectionShape = {
   run: runSummarySchema,
@@ -510,25 +530,25 @@ var runInspectionShape = {
   trace: jsonObjectSchema,
   hierarchy: jsonObjectSchema,
   ledger: jsonObjectSchema,
-  toolJournal: z6.array(jsonObjectSchema)
+  toolJournal: z5.array(jsonObjectSchema)
 };
 var cliRunInspectionDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("run-inspection"),
+  kind: z5.literal("run-inspection"),
   ...runInspectionShape
 });
 var cliRunExportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("run-export"),
+  kind: z5.literal("run-export"),
   ...runInspectionShape
 });
 var cliRunCancellationDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("run-cancellation"),
-  cascade: z6.boolean(),
+  kind: z5.literal("run-cancellation"),
+  cascade: z5.boolean(),
   run: runSummarySchema.optional(),
   parent: runSummarySchema.optional(),
-  children: z6.array(runSummarySchema).optional()
+  children: z5.array(runSummarySchema).optional()
 }).superRefine((document, context) => {
   if (!document.cascade && !document.run || document.cascade && (!document.parent || !document.children)) {
     context.addIssue({ code: "custom", message: "Cancellation payload does not match cascade mode." });
@@ -536,27 +556,27 @@ var cliRunCancellationDocumentSchema = observationalDocument({
 });
 var cliRunCleanupDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("run-cleanup"),
+  kind: z5.literal("run-cleanup"),
   before: nonnegativeInteger,
-  statuses: z6.array(z6.string().min(1)),
+  statuses: z5.array(z5.string().min(1)),
   deleted: nonnegativeInteger
 });
 var cliSessionListDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("session-list"),
-  sessions: z6.array(sessionSchema)
+  kind: z5.literal("session-list"),
+  sessions: z5.array(sessionSchema)
 });
 var cliSessionDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("session"),
+  kind: z5.literal("session"),
   session: sessionSchema
 });
 var cliChangeEnvelopeVerificationDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("change-envelope-verification"),
-  valid: z6.boolean(),
-  verificationScope: z6.literal("integrity-expiration-and-preconditions-only"),
-  issues: z6.array(jsonObjectSchema),
+  kind: z5.literal("change-envelope-verification"),
+  valid: z5.boolean(),
+  verificationScope: z5.literal("integrity-expiration-and-preconditions-only"),
+  issues: z5.array(jsonObjectSchema),
   integrity: jsonObjectSchema,
   expiration: jsonObjectSchema,
   checks: jsonObjectSchema,
@@ -565,32 +585,32 @@ var cliChangeEnvelopeVerificationDocumentSchema = observationalDocument({
 });
 var cliStateStatusDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("state-status"),
-  compatible: z6.boolean(),
+  kind: z5.literal("state-status"),
+  compatible: z5.boolean(),
   schemas: jsonObjectSchema,
-  counts: z6.record(z6.string(), nonnegativeInteger)
+  counts: z5.record(z5.string(), nonnegativeInteger)
 });
 var cliStateExportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("state-export"),
-  path: z6.string().min(1),
+  kind: z5.literal("state-export"),
+  path: z5.string().min(1),
   checksum: digestSchema,
-  counts: z6.record(z6.string(), nonnegativeInteger)
+  counts: z5.record(z5.string(), nonnegativeInteger)
 });
 var cliStateImportDocumentSchema = observationalDocument({
   ...jsonBase,
-  kind: z6.literal("state-import"),
-  dryRun: z6.boolean(),
+  kind: z5.literal("state-import"),
+  dryRun: z5.boolean(),
   checksum: digestSchema,
-  inserted: z6.record(z6.string(), nonnegativeInteger),
+  inserted: z5.record(z5.string(), nonnegativeInteger),
   identical: nonnegativeInteger
 });
 var cliErrorDocumentSchema = observationalDocument({
-  schemaVersion: z6.literal(HARNESS_ERROR_SCHEMA_VERSION),
-  kind: z6.literal("error"),
+  schemaVersion: z5.literal(HARNESS_ERROR_SCHEMA_VERSION),
+  kind: z5.literal("error"),
   error: observationalDocument({
-    code: z6.enum(HARNESS_ERROR_CODES),
-    category: z6.enum([
+    code: z5.enum(HARNESS_ERROR_CODES),
+    category: z5.enum([
       "configuration",
       "usage",
       "workspace",
@@ -599,10 +619,22 @@ var cliErrorDocumentSchema = observationalDocument({
       "approval",
       "execution"
     ]),
-    retryable: z6.boolean()
+    retryable: z5.boolean()
   })
 });
-var cliJsonDocumentSchema = z6.union([
+var cliPolicyInspectionSchema = observationalDocument({
+  ...jsonBase,
+  kind: z5.literal("policy-inspection"),
+  digest: digestSchema.nullable(),
+  source: z5.enum(["operator-file", "application", "baseline"]),
+  explicitReviewRequired: z5.boolean(),
+  tools: z5.array(observationalDocument({ name: z5.string(), requiresApproval: z5.boolean() })),
+  restrictions: z5.array(observationalDocument({ ruleId: z5.string(), tools: z5.array(z5.string()), decision: z5.enum(["allow", "ask_user", "deny"]), reason: z5.string(), pathCount: nonnegativeInteger })),
+  execution: observationalDocument({ configuredBackend: z5.enum(["none", "oci"]), activeBackend: z5.enum(["none", "oci"]), evidence: z5.literal("configuration-only") }),
+  limits: observationalDocument({ maxSteps: nonnegativeInteger, timeoutMs: nonnegativeInteger, budget: jsonObjectSchema })
+});
+var cliJsonDocumentSchema = z5.union([
+  cliPolicyInspectionSchema,
   cliRunResultDocumentSchema,
   cliInitDocumentSchema,
   cliProviderDocumentSchema,
@@ -624,47 +656,61 @@ var cliJsonDocumentSchema = z6.union([
 ]);
 var runEvent = (type, shape) => observationalDocument({
   ...eventBase,
-  kind: z6.literal("run-event"),
-  type: z6.literal(type),
+  kind: z5.literal("run-event"),
+  type: z5.literal(type),
   ...shape
 });
-var cliRunEventDocumentSchema = z6.discriminatedUnion("type", [
-  runEvent("text-delta", { textDelta: z6.string() }),
+var cliRunEventDocumentSchema = z5.discriminatedUnion("type", [
+  runEvent("policy-decision", {
+    phase: z5.enum(["approval-request", "tool-entry"]),
+    toolName: z5.string(),
+    decision: z5.enum(["allow", "ask_user", "deny"]),
+    ruleIds: z5.array(z5.string()),
+    reason: z5.string(),
+    reasonTruncated: z5.boolean(),
+    policyDigest: digestSchema.nullable(),
+    source: z5.enum(["operator-file", "application", "baseline"]),
+    approvalRequired: z5.boolean(),
+    explicitReviewRequired: z5.boolean(),
+    executionBackend: z5.enum(["none", "oci"]),
+    evidence: z5.literal("policy-evaluation")
+  }),
+  runEvent("text-delta", { textDelta: z5.string() }),
   runEvent("tool-call", {
-    toolCallId: z6.string().min(1),
-    toolName: z6.string().min(1)
+    toolCallId: z5.string().min(1),
+    toolName: z5.string().min(1)
   }),
   runEvent("tool-result", {
-    toolCallId: z6.string().min(1),
-    toolName: z6.string().min(1),
-    isError: z6.boolean()
+    toolCallId: z5.string().min(1),
+    toolName: z5.string().min(1),
+    isError: z5.boolean()
   }),
   runEvent("tool-approval-request", {
-    approvalRequestId: z6.string().min(1),
-    approvalKind: z6.string().min(1),
-    toolName: z6.string().min(1)
+    approvalRequestId: z5.string().min(1),
+    approvalKind: z5.string().min(1),
+    toolName: z5.string().min(1)
   }),
   runEvent("agent-approval-request", {
-    approvalRequestId: z6.string().min(1),
-    approvalKind: z6.string().min(1),
-    toolName: z6.string().min(1)
+    approvalRequestId: z5.string().min(1),
+    approvalKind: z5.string().min(1),
+    toolName: z5.string().min(1)
   }),
   runEvent("agent-approval-resolved", {
-    approvalRequestId: z6.string().min(1),
-    approved: z6.boolean()
+    approvalRequestId: z5.string().min(1),
+    approved: z5.boolean()
   }),
-  runEvent("provider-data", { provider: z6.string().min(1) }),
+  runEvent("provider-data", { provider: z5.string().min(1) }),
   runEvent("image-generation", {
-    provider: z6.string().min(1),
-    partial: z6.boolean(),
-    id: z6.string().min(1).optional(),
+    provider: z5.string().min(1),
+    partial: z5.boolean(),
+    id: z5.string().min(1).optional(),
     index: nonnegativeInteger.optional()
   }),
   runEvent("finish", {
-    finishReason: z6.string().min(1).optional(),
+    finishReason: z5.string().min(1).optional(),
     usage: jsonObjectSchema.optional()
   }),
-  runEvent("error", { error: z6.literal("Provider stream failed.") }),
+  runEvent("error", { error: z5.literal("Provider stream failed.") }),
   runEvent("agent-run-start", {
     currentStep: nonnegativeInteger,
     maxSteps: nonnegativeInteger
@@ -672,46 +718,46 @@ var cliRunEventDocumentSchema = z6.discriminatedUnion("type", [
   runEvent("agent-step-start", { stepIndex: nonnegativeInteger }),
   runEvent("agent-step-finish", {
     stepIndex: nonnegativeInteger,
-    status: z6.string().min(1),
+    status: z5.string().min(1),
     toolCalls: nonnegativeInteger
   }),
   runEvent("agent-compaction", {
-    compactionId: z6.string().min(1),
-    reasons: z6.array(z6.string().min(1)),
+    compactionId: z5.string().min(1),
+    reasons: z5.array(z5.string().min(1)),
     messageCountBefore: nonnegativeInteger,
     messageCountAfter: nonnegativeInteger
   }),
   runEvent("agent-run-finish", {
-    runId: z6.string().min(1),
-    status: z6.string().min(1),
-    provider: z6.string().min(1),
-    model: z6.string().min(1)
+    runId: z5.string().min(1),
+    status: z5.string().min(1),
+    provider: z5.string().min(1),
+    model: z5.string().min(1)
   })
 ]);
 var cliStreamResultDocumentSchema = observationalDocument({
   ...eventBase,
-  kind: z6.literal("run-stream-result"),
+  kind: z5.literal("run-stream-result"),
   ...runIdentity,
   steps: nonnegativeInteger,
   toolCalls: nonnegativeInteger,
-  pendingApprovals: z6.array(observationalDocument({
-    id: z6.string().min(1),
-    kind: z6.string().min(1),
-    name: z6.string().min(1),
-    childRunId: z6.string().min(1).optional(),
-    childAgentId: z6.string().min(1).optional()
+  pendingApprovals: z5.array(observationalDocument({
+    id: z5.string().min(1),
+    kind: z5.string().min(1),
+    name: z5.string().min(1),
+    childRunId: z5.string().min(1).optional(),
+    childAgentId: z5.string().min(1).optional()
   })),
-  children: z6.array(observationalDocument({
-    runId: z6.string().min(1),
-    status: z6.string().min(1)
+  children: z5.array(observationalDocument({
+    runId: z5.string().min(1),
+    status: z5.string().min(1)
   }))
 });
 var cliStreamErrorDocumentSchema = observationalDocument({
   ...eventBase,
-  kind: z6.literal("run-stream-error"),
+  kind: z5.literal("run-stream-error"),
   error: cliErrorDocumentSchema.shape.error
 });
-var cliJsonLineDocumentSchema = z6.union([
+var cliJsonLineDocumentSchema = z5.union([
   cliRunEventDocumentSchema,
   cliStreamResultDocumentSchema,
   cliStreamErrorDocumentSchema
@@ -752,6 +798,13 @@ var runServiceCli = async (options, annotate) => {
   };
   const print = (document) => process.stdout.write((options.json ? JSON.stringify(document, null, 2) : sanitizeTerminalText(JSON.stringify(document, null, 2))) + `
 `);
+  if (options.command === "policy") {
+    const result = await call({ method: "policy.get" });
+    if (result.kind !== "policy")
+      throw new HarnessStateConflictError("Unexpected service policy response.");
+    printPolicyInspection(result.policy, options.json);
+    return;
+  }
   if (options.command === "sessions") {
     if (options.sessionsCommand === "list") {
       const sessions = await list(options.sessionSearch);
@@ -822,6 +875,12 @@ var runServiceCli = async (options, annotate) => {
     const observe = (a) => {
       if (options.json || options.jsonl)
         return;
+      if (a.type === "policy-decision") {
+        const decision2 = harnessPolicyDecisionEventSchema.safeParse(a);
+        if (decision2.success)
+          process.stderr.write(formatPolicyDecision(decision2.data) + `
+`);
+      }
       history.observeService(a);
       if (a.type === "agent-step-start" || a.type === "agent-run-start")
         activity.phase("Waiting for model response");