@zhivex-ai/harness 1.1.1 → 1.2.0-rc.13

package/dist/service-client-cli-yx56n0hc.js

@@ -0,0 +1,1086 @@
+import {
+  ActivityHistory,
+  CLI_EVENT_SCHEMA_VERSION,
+  CLI_JSON_SCHEMA_VERSION,
+  ConsoleInput,
+  ToolActivity,
+  changeEnvelopeSchema,
+  formatAppliedFiles,
+  formatConsoleHelp,
+  formatConsoleWelcome,
+  navigateConsole,
+  sanitizeTerminalText,
+  serializeStreamResult
+} from "./cli-entry-c2f58zj2.js";
+import {
+  HARNESS_VERSION
+} from "./cli-entry-64pdp3k5.js";
+import {
+  HARNESS_ERROR_CODES,
+  HARNESS_ERROR_SCHEMA_VERSION,
+  HarnessConfigError,
+  HarnessStateConflictError,
+  PROVIDERS,
+  reasoningEffortSchema
+} from "./cli-entry-427869g9.js";
+import {
+  __require
+} from "./cli-entry-1bx83sw4.js";
+
+// src/cli/service-client-cli.ts
+import { randomUUID, createHash } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/client/local-service.ts
+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";
+
+// src/client/protocol.ts
+import { z } from "zod";
+var HARNESS_CLIENT_PROTOCOL_VERSION = 1;
+var id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var revision = z.number().int().nonnegative().safe();
+var scoped = { projectId: id };
+var session = { ...scoped, sessionId: id };
+var run = { ...session, runId: id };
+var mutation = { idempotencyKey: id };
+var harnessClientCommandSchema = z.discriminatedUnion("method", [
+  z.object({ method: z.literal("project.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("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({
+    method: z.literal("approval.resolve"),
+    ...run,
+    ...mutation,
+    expectedRevision: revision,
+    decisions: z.array(z.object({ approvalId: z.string().min(1).max(256), digest: z.string().regex(/^[a-f0-9]{64}$/), approve: z.boolean() }).strict()).min(1).max(64)
+  }).strict(),
+  z.object({ method: z.literal("run.cancel"), ...run, ...mutation, expectedRevision: revision }).strict()
+]);
+var harnessClientRequestSchema = z.object({
+  protocolVersion: z.literal(HARNESS_CLIENT_PROTOCOL_VERSION),
+  requestId: id,
+  connectionId: id,
+  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);
+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";
+
+// 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 readHarnessLocalCredentials = async (filename) => {
+  const { constants } = await import("node:fs");
+  const file2 = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const info = await file2.stat();
+    if (!info.isFile() || (info.mode & 63) !== 0 || info.uid !== process.getuid?.() || info.size > 4096)
+      throw new Error("LOCAL_SERVICE_CREDENTIALS_UNSAFE");
+    return harnessLocalCredentialsSchema.parse(JSON.parse(await file2.readFile("utf8")));
+  } finally {
+    await file2.close();
+  }
+};
+var requestHarnessLocalService = async (credentials, endpoint, payload) => {
+  const parsed = harnessLocalCredentialsSchema.parse(credentials);
+  if (!path.isAbsolute(parsed.socketPath) || process.platform === "win32")
+    throw new Error("LOCAL_SERVICE_SOCKET_INVALID");
+  const encoded = JSON.stringify(payload);
+  if (Buffer.byteLength(encoded) > 131072)
+    throw new Error("REQUEST_TOO_LARGE");
+  return new Promise((resolve, reject) => {
+    const req = httpRequest({ socketPath: parsed.socketPath, path: `/${endpoint}`, method: "POST", headers: {
+      authorization: `Bearer ${parsed.token}`,
+      "content-type": "application/json",
+      "content-length": Buffer.byteLength(encoded)
+    } }, (res) => {
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > 4194304)
+          res.destroy(new Error("RESPONSE_TOO_LARGE"));
+        else
+          chunks.push(chunk);
+      });
+      res.on("error", reject);
+      res.on("end", () => {
+        try {
+          if (res.statusCode !== 200)
+            return reject(new Error(`LOCAL_SERVICE_HTTP_${res.statusCode}`));
+          resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+        } catch {
+          reject(new Error("LOCAL_SERVICE_RESPONSE_INVALID"));
+        }
+      });
+    });
+    req.on("error", () => reject(new Error("LOCAL_SERVICE_UNAVAILABLE")));
+    req.end(encoded);
+  });
+};
+
+// 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) };
+var eventBase = {
+  schemaVersion: z6.literal(CLI_EVENT_SCHEMA_VERSION),
+  sequence: z6.number().int().nonnegative()
+};
+var nonnegativeInteger = z6.number().int().nonnegative();
+var digestSchema = z6.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()
+});
+var runIdentity = {
+  runId: z6.string().min(1),
+  status: z6.string().min(1),
+  provider: z6.string().min(1),
+  model: z6.string().min(1)
+};
+var runSummarySchema = observationalDocument({
+  ...runIdentity,
+  revision: nonnegativeInteger,
+  scope: scopeSchema,
+  steps: nonnegativeInteger,
+  toolCalls: nonnegativeInteger,
+  toolErrors: nonnegativeInteger,
+  pendingApprovals: nonnegativeInteger,
+  compactions: nonnegativeInteger,
+  childRuns: nonnegativeInteger,
+  startedAt: nonnegativeInteger,
+  updatedAt: nonnegativeInteger
+});
+var sessionRunSchema = observationalDocument({
+  turnId: z6.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),
+  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),
+  revision: nonnegativeInteger,
+  createdAt: nonnegativeInteger,
+  updatedAt: nonnegativeInteger,
+  runs: z6.array(sessionRunSchema)
+});
+var tokenUsageSchema = observationalDocument({
+  inputTokens: nonnegativeInteger.optional(),
+  cachedInputTokens: nonnegativeInteger.optional(),
+  cacheWriteTokens: nonnegativeInteger.optional(),
+  outputTokens: nonnegativeInteger.optional(),
+  reasoningTokens: nonnegativeInteger.optional(),
+  totalTokens: nonnegativeInteger.optional(),
+  speed: z6.enum(["standard", "fast"]).optional()
+});
+var budgetConfigSchema = observationalDocument({
+  unlimitedTokens: z6.boolean().optional(),
+  maxSteps: nonnegativeInteger,
+  maxToolCalls: nonnegativeInteger,
+  maxToolErrors: nonnegativeInteger,
+  maxInputTokens: nonnegativeInteger,
+  maxOutputTokens: nonnegativeInteger,
+  maxTotalTokens: nonnegativeInteger,
+  includeChildRuns: z6.boolean()
+});
+var budgetConsumptionSchema = observationalDocument({
+  steps: nonnegativeInteger,
+  toolCalls: nonnegativeInteger,
+  toolErrors: nonnegativeInteger,
+  inputTokens: nonnegativeInteger,
+  outputTokens: nonnegativeInteger,
+  totalTokens: nonnegativeInteger
+});
+var budgetRemainingSchema = observationalDocument({
+  steps: nonnegativeInteger.optional(),
+  toolCalls: nonnegativeInteger.optional(),
+  toolErrors: nonnegativeInteger.optional(),
+  inputTokens: nonnegativeInteger.optional(),
+  outputTokens: nonnegativeInteger.optional(),
+  totalTokens: nonnegativeInteger.optional()
+});
+var budgetStatusSchema = observationalDocument({
+  consumption: budgetConsumptionSchema,
+  remaining: budgetRemainingSchema,
+  includeChildRuns: z6.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(),
+  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(),
+  beforeDigest: digestSchema.optional(),
+  afterDigest: digestSchema.optional(),
+  timestamp: z6.iso.datetime(),
+  quarantineId: z6.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()
+});
+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),
+  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(),
+  capabilities: observationalDocument({
+    streaming: z6.boolean(),
+    tools: z6.boolean(),
+    "structured-output": z6.boolean(),
+    "parallel-tools": z6.boolean(),
+    reasoning: z6.boolean(),
+    "web-search": z6.boolean()
+  })
+});
+var providerConfigurationSchema = z6.object({
+  customEndpoint: z6.boolean(),
+  endpointValid: z6.boolean(),
+  endpointSecure: z6.boolean()
+}).catchall(z6.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()
+  })),
+  configuration: providerConfigurationSchema
+});
+var orchestrationConfigSchema = observationalDocument({
+  profiles: z6.array(z6.enum(["explorer", "implementer", "tester", "reviewer"])),
+  childBudget: budgetConfigSchema,
+  childTimeoutMs: nonnegativeInteger,
+  maxParallelReviews: nonnegativeInteger
+});
+var executionConfigSchema = z6.discriminatedUnion("backend", [
+  observationalDocument({ backend: z6.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"]),
+    maxProcessRuntimeMs: nonnegativeInteger,
+    maxProcessOutputBytes: nonnegativeInteger,
+    maxMemoryMb: nonnegativeInteger,
+    maxPids: nonnegativeInteger,
+    maxCpus: z6.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()
+});
+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)
+});
+var runExecutionSchema = z6.discriminatedUnion("backend", [
+  observationalDocument({ backend: z6.literal("none") }),
+  observationalDocument({
+    backend: z6.literal("oci"),
+    binding: executionBindingSchema,
+    image: ociImageSchema
+  })
+]);
+var migrationResultSchema = observationalDocument({
+  scannedRuns: nonnegativeInteger,
+  migratedRuns: nonnegativeInteger,
+  migratedToolCalls: nonnegativeInteger
+});
+var runStoreSchema = observationalDocument({
+  backend: z6.enum(["sqlite", "file"]),
+  stateDirectory: z6.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())
+  ]))
+});
+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"]),
+  scope: scopeSchema,
+  maxSteps: nonnegativeInteger,
+  timeoutMs: nonnegativeInteger,
+  budget: budgetConfigSchema,
+  costBudget: observationalDocument({
+    maxCostUsd: z6.number().nonnegative(),
+    inputCostPer1kTokens: z6.number().nonnegative(),
+    outputCostPer1kTokens: z6.number().nonnegative()
+  }).optional(),
+  compaction: observationalDocument({
+    maxMessages: nonnegativeInteger,
+    maxEstimatedInputTokens: nonnegativeInteger,
+    keepRecentMessages: nonnegativeInteger
+  }),
+  allowedChecks: z6.array(z6.string().min(1)),
+  requiredCapabilities: z6.array(z6.enum([
+    "streaming",
+    "tools",
+    "structured-output",
+    "parallel-tools",
+    "reasoning",
+    "web-search"
+  ])),
+  orchestration: orchestrationConfigSchema,
+  context: observationalDocument({ enabled: z6.boolean(), configPath: z6.string().min(1) }),
+  execution: executionConfigSchema,
+  mcpConfigPath: z6.string().min(1).optional()
+});
+var cliRunResultDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("run-result"),
+  ...runIdentity,
+  output: z6.string(),
+  steps: nonnegativeInteger,
+  toolCalls: nonnegativeInteger,
+  mutations: z6.array(mutationAuditSchema),
+  pendingApprovals: z6.array(approvalSummarySchema),
+  children: z6.array(childRunSummarySchema),
+  usage: tokenUsageSchema.optional(),
+  budget: budgetStatusSchema,
+  costBudget: observationalDocument({
+    limitUsd: z6.number().nonnegative(),
+    estimate: costEstimateSchema
+  }).optional(),
+  scope: scopeSchema,
+  capabilities: capabilityReportSchema,
+  orchestration: observationalDocument({
+    profiles: orchestrationConfigSchema.shape.profiles,
+    childBudget: budgetConfigSchema,
+    mcpServers: z6.array(z6.string().min(1))
+  }),
+  execution: runExecutionSchema,
+  store: runStoreSchema,
+  stateDirectory: z6.string()
+});
+var cliProviderDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("providers"),
+  providers: z6.array(providerAvailabilitySchema)
+});
+var cliInitDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("init"),
+  profile: observationalDocument({
+    name: z6.string().min(1),
+    path: z6.string().min(1),
+    schemaVersion: nonnegativeInteger,
+    provider: z6.enum(PROVIDERS),
+    model: z6.string().min(1),
+    reasoningEffort: reasoningEffortSchema.optional()
+  }),
+  credential: observationalDocument({
+    configured: z6.boolean(),
+    names: z6.array(z6.string().min(1))
+  }),
+  next: observationalDocument({
+    doctor: z6.string().min(1),
+    run: z6.string().min(1)
+  })
+});
+var cliDoctorDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("doctor"),
+  ok: z6.boolean(),
+  harnessVersion: z6.string().min(1),
+  configSchemaVersion: nonnegativeInteger,
+  configuration: doctorConfigurationSchema,
+  checks: z6.array(doctorCheckSchema),
+  providers: z6.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(),
+    steps: nonnegativeInteger.optional(),
+    usage: tokenUsageSchema.optional(),
+    error: observationalDocument({
+      code: z6.enum(HARNESS_ERROR_CODES),
+      category: z6.enum([
+        "configuration",
+        "usage",
+        "workspace",
+        "state",
+        "provider",
+        "approval",
+        "execution"
+      ]),
+      retryable: z6.boolean()
+    }).optional()
+  }))
+});
+var cliRunListDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("run-list"),
+  scope: scopeSchema,
+  backend: z6.string().min(1),
+  runs: z6.array(runSummarySchema)
+});
+var runInspectionShape = {
+  run: runSummarySchema,
+  budget: jsonObjectSchema,
+  snapshot: jsonObjectSchema,
+  trace: jsonObjectSchema,
+  hierarchy: jsonObjectSchema,
+  ledger: jsonObjectSchema,
+  toolJournal: z6.array(jsonObjectSchema)
+};
+var cliRunInspectionDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("run-inspection"),
+  ...runInspectionShape
+});
+var cliRunExportDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("run-export"),
+  ...runInspectionShape
+});
+var cliRunCancellationDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("run-cancellation"),
+  cascade: z6.boolean(),
+  run: runSummarySchema.optional(),
+  parent: runSummarySchema.optional(),
+  children: z6.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." });
+  }
+});
+var cliRunCleanupDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("run-cleanup"),
+  before: nonnegativeInteger,
+  statuses: z6.array(z6.string().min(1)),
+  deleted: nonnegativeInteger
+});
+var cliSessionListDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("session-list"),
+  sessions: z6.array(sessionSchema)
+});
+var cliSessionDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.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),
+  integrity: jsonObjectSchema,
+  expiration: jsonObjectSchema,
+  checks: jsonObjectSchema,
+  approvals: jsonObjectSchema,
+  externalAttestations: jsonObjectSchema
+});
+var cliStateStatusDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("state-status"),
+  compatible: z6.boolean(),
+  schemas: jsonObjectSchema,
+  counts: z6.record(z6.string(), nonnegativeInteger)
+});
+var cliStateExportDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("state-export"),
+  path: z6.string().min(1),
+  checksum: digestSchema,
+  counts: z6.record(z6.string(), nonnegativeInteger)
+});
+var cliStateImportDocumentSchema = observationalDocument({
+  ...jsonBase,
+  kind: z6.literal("state-import"),
+  dryRun: z6.boolean(),
+  checksum: digestSchema,
+  inserted: z6.record(z6.string(), nonnegativeInteger),
+  identical: nonnegativeInteger
+});
+var cliErrorDocumentSchema = observationalDocument({
+  schemaVersion: z6.literal(HARNESS_ERROR_SCHEMA_VERSION),
+  kind: z6.literal("error"),
+  error: observationalDocument({
+    code: z6.enum(HARNESS_ERROR_CODES),
+    category: z6.enum([
+      "configuration",
+      "usage",
+      "workspace",
+      "state",
+      "provider",
+      "approval",
+      "execution"
+    ]),
+    retryable: z6.boolean()
+  })
+});
+var cliJsonDocumentSchema = z6.union([
+  cliRunResultDocumentSchema,
+  cliInitDocumentSchema,
+  cliProviderDocumentSchema,
+  cliDoctorDocumentSchema,
+  cliReviewGroupDocumentSchema,
+  cliRunListDocumentSchema,
+  cliRunInspectionDocumentSchema,
+  cliRunExportDocumentSchema,
+  cliRunCancellationDocumentSchema,
+  cliRunCleanupDocumentSchema,
+  cliSessionListDocumentSchema,
+  cliSessionDocumentSchema,
+  cliChangeEnvelopeVerificationDocumentSchema,
+  cliStateStatusDocumentSchema,
+  cliStateExportDocumentSchema,
+  cliStateImportDocumentSchema,
+  cliErrorDocumentSchema,
+  changeEnvelopeSchema
+]);
+var runEvent = (type, shape) => observationalDocument({
+  ...eventBase,
+  kind: z6.literal("run-event"),
+  type: z6.literal(type),
+  ...shape
+});
+var cliRunEventDocumentSchema = z6.discriminatedUnion("type", [
+  runEvent("text-delta", { textDelta: z6.string() }),
+  runEvent("tool-call", {
+    toolCallId: z6.string().min(1),
+    toolName: z6.string().min(1)
+  }),
+  runEvent("tool-result", {
+    toolCallId: z6.string().min(1),
+    toolName: z6.string().min(1),
+    isError: z6.boolean()
+  }),
+  runEvent("tool-approval-request", {
+    approvalRequestId: z6.string().min(1),
+    approvalKind: z6.string().min(1),
+    toolName: z6.string().min(1)
+  }),
+  runEvent("agent-approval-request", {
+    approvalRequestId: z6.string().min(1),
+    approvalKind: z6.string().min(1),
+    toolName: z6.string().min(1)
+  }),
+  runEvent("agent-approval-resolved", {
+    approvalRequestId: z6.string().min(1),
+    approved: z6.boolean()
+  }),
+  runEvent("provider-data", { provider: z6.string().min(1) }),
+  runEvent("image-generation", {
+    provider: z6.string().min(1),
+    partial: z6.boolean(),
+    id: z6.string().min(1).optional(),
+    index: nonnegativeInteger.optional()
+  }),
+  runEvent("finish", {
+    finishReason: z6.string().min(1).optional(),
+    usage: jsonObjectSchema.optional()
+  }),
+  runEvent("error", { error: z6.literal("Provider stream failed.") }),
+  runEvent("agent-run-start", {
+    currentStep: nonnegativeInteger,
+    maxSteps: nonnegativeInteger
+  }),
+  runEvent("agent-step-start", { stepIndex: nonnegativeInteger }),
+  runEvent("agent-step-finish", {
+    stepIndex: nonnegativeInteger,
+    status: z6.string().min(1),
+    toolCalls: nonnegativeInteger
+  }),
+  runEvent("agent-compaction", {
+    compactionId: z6.string().min(1),
+    reasons: z6.array(z6.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)
+  })
+]);
+var cliStreamResultDocumentSchema = observationalDocument({
+  ...eventBase,
+  kind: z6.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()
+  })),
+  children: z6.array(observationalDocument({
+    runId: z6.string().min(1),
+    status: z6.string().min(1)
+  }))
+});
+var cliStreamErrorDocumentSchema = observationalDocument({
+  ...eventBase,
+  kind: z6.literal("run-stream-error"),
+  error: cliErrorDocumentSchema.shape.error
+});
+var cliJsonLineDocumentSchema = z6.union([
+  cliRunEventDocumentSchema,
+  cliStreamResultDocumentSchema,
+  cliStreamErrorDocumentSchema
+]);
+
+// src/cli/service-client-cli.ts
+var runServiceCli = async (options, annotate) => {
+  const credentials = await readHarnessLocalCredentials(options.serviceFile);
+  const hello = await requestHarnessLocalService(credentials, "hello", { versions: [1] });
+  if (!hello.ok)
+    throw new HarnessStateConflictError("Service negotiation failed.");
+  const projectId = hello.projectId;
+  let sequence = 0;
+  const key = (purpose, supplied) => createHash("sha256").update(`${purpose}:${supplied ?? randomUUID()}`).digest("hex");
+  const call = async (command) => {
+    const r = await requestHarnessLocalService(credentials, "command", { protocolVersion: 1, requestId: `request_${randomUUID()}`, connectionId: hello.connectionId, command: { projectId, ...command } });
+    if (!r.ok)
+      throw new HarnessStateConflictError(`Service command failed: ${r.error.code}. Inspect durable state before retrying.`);
+    return r.data;
+  };
+  const getSession = async (sessionId) => {
+    const r = await call({ method: "session.get", sessionId });
+    if (r.kind !== "session")
+      throw new HarnessStateConflictError("Unexpected service response.");
+    return r.session;
+  };
+  const list = async (search) => {
+    const r = await call({ method: "session.list", ...search ? { search } : {} });
+    if (r.kind !== "sessions")
+      throw new HarnessStateConflictError("Unexpected service response.");
+    return r.sessions;
+  };
+  const create = async (idempotencyKey) => {
+    const r = await call({ method: "session.create", idempotencyKey: key("session", idempotencyKey) });
+    if (r.kind !== "session")
+      throw new HarnessStateConflictError("Unexpected service response.");
+    return r.session;
+  };
+  const print = (document) => process.stdout.write((options.json ? JSON.stringify(document, null, 2) : sanitizeTerminalText(JSON.stringify(document, null, 2))) + `
+`);
+  if (options.command === "sessions") {
+    if (options.sessionsCommand === "list") {
+      const sessions = await list(options.sessionSearch);
+      print({ schemaVersion: 1, kind: "session-list", sessions });
+      return;
+    }
+    let session3 = await getSession(options.sessionId);
+    if (options.sessionsCommand === "rename") {
+      const renamed = await call({ method: "session.rename", sessionId: session3.sessionId, expectedRevision: session3.revision, idempotencyKey: key("rename"), title: options.sessionTitle });
+      if (renamed.kind !== "session")
+        throw new HarnessStateConflictError("Unexpected response.");
+      session3 = renamed.session;
+    } else if (options.sessionsCommand !== "inspect")
+      throw new HarnessConfigError("Unsupported service session command.");
+    print({ schemaVersion: 1, kind: "session", session: session3 });
+    return;
+  }
+  if (!["run", "resume", "chat"].includes(options.command))
+    throw new HarnessConfigError("This command does not support service mode.");
+  let session2;
+  if (options.sessionId)
+    session2 = await getSession(options.sessionId);
+  else if (options.command === "resume") {
+    const found = (await list()).find((s) => s.runs.some((r) => r.runId === options.runId));
+    if (!found)
+      throw new HarnessStateConflictError("Run session not found; supply --session.");
+    session2 = found;
+  } else if (options.continueSession) {
+    const latest = (await list())[0];
+    if (!latest)
+      throw new HarnessStateConflictError("No session to continue.");
+    session2 = latest;
+  } else
+    session2 = await create(options.idempotencyKey);
+  let activeRun;
+  let consoleInput;
+  const history = new ActivityHistory;
+  const seenMutations = new Set;
+  const currentRun = async (runId = activeRun ?? session2.runs.at(-1)?.runId) => {
+    if (!runId)
+      return;
+    const r = await call({ method: "run.get", sessionId: session2.sessionId, runId });
+    if (r.kind !== "run")
+      throw new HarnessStateConflictError("Unexpected run response.");
+    return r.run;
+  };
+  const cancel = async () => {
+    const run2 = await currentRun();
+    if (run2)
+      await call({ method: "run.cancel", sessionId: session2.sessionId, runId: run2.runId, expectedRevision: run2.revision, idempotencyKey: key("cancel") });
+  };
+  const cursorAtEnd = async () => {
+    let after = 0;
+    for (;; ) {
+      const page = await requestHarnessLocalService(credentials, "events", { projectId, sessionId: session2.sessionId, after });
+      after = page.nextCursor;
+      if (page.cursorExpired || page.events.length < 200)
+        return after;
+    }
+  };
+  const invoke = async (command) => {
+    let cursor = await cursorAtEnd();
+    let finished = false, streamed = false;
+    consoleInput?.startBackground();
+    const activity = new ToolActivity((text) => {
+      process.stderr.write(text);
+    }, Boolean(consoleInput && process.stdout.isTTY), () => process.stdout.columns || 80, () => consoleInput?.backgroundStatus ?? "");
+    const observe = (a) => {
+      if (options.json || options.jsonl)
+        return;
+      history.observeService(a);
+      if (a.type === "agent-step-start" || a.type === "agent-run-start")
+        activity.phase("Waiting for model response");
+      else if (a.type === "agent-compaction")
+        activity.phase("Updating context");
+      else if (a.type === "tool-call")
+        activity.start(typeof a.toolName === "string" ? a.toolName : undefined);
+      else if (a.type === "tool-result")
+        activity.finish(typeof a.toolName === "string" ? a.toolName : "tool", a.isError !== true);
+      else if (["agent-run-finish", "tool-approval-request", "agent-approval-request"].includes(String(a.type)))
+        activity.flush();
+      else if (a.type === "text-delta")
+        activity.pause();
+    };
+    const pending = call(command).finally(() => {
+      finished = true;
+    });
+    pending.catch(() => {
+      return;
+    });
+    try {
+      do {
+        const page = await requestHarnessLocalService(credentials, "events", { projectId, sessionId: session2.sessionId, after: cursor });
+        if (page.cursorExpired)
+          throw new HarnessStateConflictError("Service activity cursor expired; reopen the session snapshot.");
+        cursor = page.nextCursor;
+        for (const event of page.events) {
+          activeRun = event.runId;
+          const a = event.activity;
+          if (a.type === "checkpoint" || a.type === "user-message")
+            continue;
+          observe(a);
+          if (options.jsonl)
+            process.stdout.write(JSON.stringify({ ...a, schemaVersion: 1, kind: "run-event", sequence: ++sequence }) + `
+`);
+          else if (!options.json && typeof a.textDelta === "string") {
+            process.stdout.write(sanitizeTerminalText(a.textDelta));
+            streamed = true;
+          }
+        }
+        if (!finished)
+          await Promise.race([pending.then(() => {
+            return;
+          }, () => {
+            return;
+          }), delay(40)]);
+      } while (!finished);
+      for (;; ) {
+        const tail = await requestHarnessLocalService(credentials, "events", { projectId, sessionId: session2.sessionId, after: cursor });
+        if (tail.cursorExpired)
+          throw new HarnessStateConflictError("Service activity cursor expired; inspect session.");
+        for (const event of tail.events) {
+          const a = event.activity;
+          if (a.type === "checkpoint" || a.type === "user-message")
+            continue;
+          observe(a);
+          if (options.jsonl)
+            process.stdout.write(JSON.stringify({ ...a, schemaVersion: 1, kind: "run-event", sequence: ++sequence }) + `
+`);
+          else if (!options.json && typeof a.textDelta === "string") {
+            process.stdout.write(sanitizeTerminalText(a.textDelta));
+            streamed = true;
+          }
+        }
+        cursor = tail.nextCursor;
+        if (tail.events.length < 200)
+          break;
+      }
+      const result = await pending;
+      if (result.kind !== "run")
+        throw new HarnessStateConflictError("Unexpected run response.");
+      session2 = result.session;
+      return { run: result.run, streamed };
+    } catch (e) {
+      throw annotate(e, sequence);
+    } finally {
+      activity.flush();
+      consoleInput?.stopBackground();
+      activeRun = undefined;
+    }
+  };
+  const finish = (run2, streamed) => {
+    const document = cliRunResultDocumentSchema.parse(run2.cliResult);
+    if (options.jsonl)
+      process.stdout.write(serializeStreamResult({ runId: document.runId, status: document.status, provider: document.provider, model: document.model, steps: document.steps, toolCalls: document.toolCalls, pendingApprovals: document.pendingApprovals.map((a) => ({ id: a.id, kind: a.kind, name: a.name, ...a.childRunId ? { childRunId: a.childRunId } : {}, ...a.childAgentId ? { childAgentId: a.childAgentId } : {} })), children: document.children.map((c) => ({ runId: c.runId, status: c.status })) }, ++sequence) + `
+`);
+    else if (options.json)
+      print({ ...document, sessionId: session2.sessionId });
+    else {
+      if (!streamed)
+        process.stdout.write(sanitizeTerminalText(document.output));
+      process.stdout.write(`
+Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
+`);
+    }
+    if (!options.json && !options.jsonl) {
+      const fresh = document.mutations.filter((entry) => !seenMutations.has(entry.id));
+      for (const entry of fresh)
+        seenMutations.add(entry.id);
+      while (seenMutations.size > 2000)
+        seenMutations.delete(seenMutations.values().next().value);
+      const receipt = formatAppliedFiles(fresh, "Review changes in the host workspace");
+      if (receipt) {
+        process.stdout.write(receipt);
+        history.add(receipt.trim());
+      }
+    }
+    if (["failed", "cancelled", "timed_out"].includes(run2.status))
+      process.exitCode = 1;
+  };
+  const decision = async (run2, approve) => invoke({ method: "approval.resolve", sessionId: session2.sessionId, runId: run2.runId, expectedRevision: run2.revision, idempotencyKey: key("decision"), decisions: run2.approvals.map((a) => ({ approvalId: a.approvalId, digest: a.digest, approve })) });
+  const start = async (prompt) => {
+    session2 = await getSession(session2.sessionId);
+    let result = await invoke({ method: "run.start", sessionId: session2.sessionId, expectedRevision: session2.revision, idempotencyKey: key("run", options.idempotencyKey), prompt });
+    while (options.yes && result.run.status === "waiting_approval")
+      result = await decision(result.run, true);
+    finish(result.run, result.streamed);
+  };
+  const interrupt = () => {
+    if (!activeRun)
+      return;
+    cancel().catch(() => process.stderr.write(`Cancellation conflicted; inspect the run before retrying.
+`));
+  };
+  process.on("SIGINT", interrupt);
+  try {
+    if (options.command === "resume") {
+      const run2 = await currentRun(options.runId);
+      if (!run2)
+        throw new HarnessStateConflictError("Run not found.");
+      const result = await decision(run2, options.approve === true);
+      finish(result.run, result.streamed);
+      return;
+    }
+    if (options.command === "run") {
+      let prompt = options.prompt ?? "";
+      if (!prompt && !process.stdin.isTTY) {
+        for await (const chunk of process.stdin) {
+          prompt += chunk.toString();
+          if (Buffer.byteLength(prompt) > 64 * 1024)
+            throw new HarnessConfigError("Prompt exceeds 64 KiB.");
+        }
+      }
+      if (!prompt.trim())
+        throw new HarnessConfigError("A prompt is required.");
+      await start(prompt);
+      return;
+    }
+    const input = new ConsoleInput(process.stdin, process.stdout, Boolean(process.stdin.isTTY), "service");
+    input.onInterrupt = interrupt;
+    consoleInput = input;
+    try {
+      process.stdout.write(formatConsoleWelcome({ version: HARNESS_VERSION, workspace: projectId, sessionId: session2.sessionId, service: true }, { columns: process.stdout.columns ?? 80 }) + `
+`);
+      const previous = await currentRun();
+      if (previous)
+        print(previous);
+      for (;; ) {
+        input.setQueueEnabled(!session2.runs.some((run2) => ["created", "running", "waiting_approval"].includes(run2.status)));
+        const raw = await input.compose({ model: "local service", status: session2.runs.at(-1)?.status === "waiting_approval" ? "approval pending · /pending" : "ready", ...session2.title ? { title: session2.title } : {}, automaticApprovals: options.yes === true }).catch((e) => {
+          if (input.isClosed)
+            return "/exit";
+          if (e instanceof Error && e.name === "AbortError")
+            return "";
+          throw e;
+        });
+        const literal = input.lastSubmissionWasPaste || raw.includes(`
+`);
+        let text = literal ? raw : raw.trim();
+        if (!text)
+          continue;
+        if (!literal && ["/exit", "/quit"].includes(text))
+          break;
+        try {
+          if (!literal && text.startsWith("/")) {
+            if (text === "/menu") {
+              const selected = await navigateConsole(input, { entry: "menu", current: { provider: "service", model: "host" }, providers: [], service: true, sessions: async () => (await list()).map((s) => ({ value: s.sessionId, label: s.title ?? "Untitled conversation", detail: s.sessionId })) });
+              if (!selected || !("command" in selected))
+                continue;
+              text = selected.command;
+            }
+            if (text === "/help" || text === "/help all")
+              process.stdout.write(formatConsoleHelp("service", text === "/help all"));
+            else if (text === "/activity" || text === "/activity clear") {
+              if (text.endsWith(" clear"))
+                history.clear();
+              process.stdout.write(history.render());
+            } else if (text === "/queue clear") {
+              input.clearQueue();
+              process.stdout.write(`Queued tasks cleared.
+`);
+            } else if (text === "/queue")
+              process.stdout.write(input.queueSummary());
+            else if (text === "/sessions" || text.startsWith("/sessions "))
+              print(await list(text.slice(9).trim() || undefined));
+            else if (text === "/new") {
+              session2 = await create();
+              input.clearHistory();
+              history.clear();
+              seenMutations.clear();
+              process.stdout.write(`Session ${session2.sessionId}.
+`);
+            } else if (text === "/resume" || text.startsWith("/resume ")) {
+              let id2 = text.slice(7).trim();
+              if (!id2) {
+                const selected = await input.select("Zhivex / Conversations", (await list()).map((s) => ({ value: s.sessionId, label: s.title ?? "Untitled conversation", detail: s.sessionId })));
+                if (!selected)
+                  continue;
+                id2 = selected;
+              }
+              session2 = await getSession(id2);
+              input.clearHistory();
+              history.clear();
+              seenMutations.clear();
+              print(await currentRun());
+            } else if (text.startsWith("/rename ")) {
+              const r = await call({ method: "session.rename", sessionId: session2.sessionId, expectedRevision: session2.revision, idempotencyKey: key("rename"), title: text.slice(8) });
+              if (r.kind === "session")
+                session2 = r.session;
+            } else if (["/status", "/pending"].includes(text))
+              print(await currentRun() ?? { message: "No run yet." });
+            else if (text === "/paste") {
+              const draft = await input.multiline();
+              process.stdout.write(`Draft preview:
+${sanitizeTerminalText(draft)}
+`);
+              if ((await input.question("Send this draft? Type send: ")).trim() === "send" && draft.trim()) {
+                input.rememberPrompt(draft, true);
+                await start(draft);
+              }
+            } else if (text === "/cancel")
+              await cancel();
+            else if (["/approve", "/deny"].includes(text)) {
+              const run2 = await currentRun();
+              if (run2) {
+                const r = await decision(run2, text === "/approve");
+                finish(r.run, r.streamed);
+              }
+            } else
+              process.stdout.write(`Unsupported service command. Use /help.
+`);
+          } else {
+            input.rememberPrompt(text, literal);
+            await start(text);
+          }
+        } catch {
+          if (input.isClosed)
+            break;
+          process.stderr.write(`Service operation failed. Inspect /status before retrying.
+`);
+        }
+      }
+    } finally {
+      input.close();
+    }
+  } finally {
+    process.off("SIGINT", interrupt);
+  }
+};
+export {
+  runServiceCli
+};