@zhivex-ai/harness 1.4.0 → 1.4.1

package/dist/engine/mcp-stdio-v1.js

@@ -8,12 +8,14 @@ import {
   mcpResourcePlanSchema,
   prepareMcpWorkspaceSnapshot,
   recoverDockerMcpResources
-} from "../index-rkbf7dqg.js";
-import"../index-pdmevfxv.js";
-import"../index-m34q25jj.js";
-import"../index-8zjmnyw5.js";
-import"../index-m49jx72n.js";
-import"../index-xqxeypt5.js";
+} from "../index-mv8sb1ns.js";
+import"../index-dtb2c6ds.js";
+import"../index-d9zkmhz3.js";
+import"../index-1265j7t2.js";
+import"../index-c39197wq.js";
+import"../index-mzydbzp8.js";
+import"../index-4fx5f3k5.js";
+import"../index-xdbkcccf.js";
 import"../index-bpc596v3.js";
 import"../index-fm84men1.js";
 import"../index-1bx83sw4.js";

package/dist/engine/models.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 // src/models/catalog.json
 var catalog_default = {
   schemaVersion: 1,
-  revision: "2026-09-29-vertex",
+  revision: "2026-10-15-bedrock-azure",
   providers: [
     {
       id: "openai",
@@ -768,6 +768,78 @@ var catalog_default = {
           reason: "Provisional Vertex route; availability depends on project, region and IAM. No live certification."
         }
       ]
+    },
+    {
+      id: "bedrock",
+      defaultModel: "anthropic.claude-haiku-5-5",
+      models: [
+        {
+          id: "anthropic.claude-haiku-5-5",
+          name: "Claude Haiku 5.5 (Bedrock)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock Converse route. Account access, region, and live Harness certification are not verified. No prices or context limits are inferred."
+        },
+        {
+          id: "anthropic.claude-sonnet-5-5",
+          name: "Claude Sonnet 5.5 (Bedrock)",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock model id. Availability depends on the account and region. No live certification."
+        },
+        {
+          id: "amazon.nova-2-lite-v1:0",
+          name: "Amazon Nova 2 Lite (Bedrock)",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Bedrock model id. Availability depends on the account and region. No live certification."
+        }
+      ]
+    },
+    {
+      id: "azure-openai",
+      defaultModel: "gpt-5.4",
+      models: [
+        {
+          id: "gpt-5.4",
+          name: "GPT-5.4 (Azure OpenAI)",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI route. Deployment name, API version, and live Harness certification are not verified. No prices are copied from the OpenAI API."
+        },
+        {
+          id: "gpt-5",
+          name: "GPT-5 (Azure OpenAI)",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI model id. Use AZURE_OPENAI_DEPLOYMENTS when the deployment name differs. No live certification."
+        },
+        {
+          id: "gpt-6-astra",
+          name: "GPT-6 Astra (Azure OpenAI)",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: ["chat", "tools"],
+          reason: "Provisional Azure OpenAI model id. Account rollout and deployment availability are not verified. No live certification."
+        }
+      ]
     }
   ]
 };
@@ -830,13 +902,13 @@ var modelCatalogSchema = z.object({
   schemaVersion: z.literal(1),
   revision: z.string().min(1).max(80).regex(/^[a-zA-Z0-9._-]+$/),
   providers: z.array(z.object({
-    id: z.enum(["openai", "qwen", "gemini", "meta", "anthropic", "vertex"]),
+    id: z.enum(["openai", "qwen", "gemini", "meta", "anthropic", "vertex", "bedrock", "azure-openai"]),
     defaultModel: modelId,
     models: z.array(catalogModelSchema).min(1).max(500)
-  }).strict()).length(6)
+  }).strict()).length(8)
 }).strict().superRefine((catalog, ctx) => {
   const invalid = (message) => ctx.addIssue({ code: "custom", message });
-  if (new Set(catalog.providers.map((p) => p.id)).size !== 6)
+  if (new Set(catalog.providers.map((p) => p.id)).size !== 8)
     invalid("Duplicate providers");
   for (const provider of catalog.providers) {
     const ids = new Set(provider.models.map((m) => m.id));

package/dist/engine/protocol.d.ts

@@ -5,3 +5,5 @@ export { CLI_JSON_SCHEMA_VERSION, CLI_EVENT_SCHEMA_VERSION, streamEventDocument,
 export type { StreamRunResultSource } from "../client/stream.js";
 export type { HarnessActivityEvent, HarnessActivityRun, HarnessActivitySnapshot, HarnessActivityPage } from "../client/service-events.js";
 export type { ApprovalDecisionView } from "../approvals/approval-history.js";
+export { HARNESS_TASK_PROJECTION_VERSION, harnessTaskProjectionSchema, reduceHarnessTaskProjection } from '../client/task-projection.js';
+export type { HarnessTaskProjection, HarnessTaskProjectionScope } from '../client/task-projection.js';

package/dist/engine/protocol.js

@@ -38,6 +38,24 @@ var harnessClientCommandSchema = z.discriminatedUnion("method", [
   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("task.start"),
+    ...session,
+    ...mutation,
+    expectedRevision: revision,
+    brief: z.strictObject({
+      goal: z.string().trim().min(1).max(2000),
+      paths: z.array(z.string().min(1).max(1024)).min(1).max(20),
+      checks: z.array(id).min(1).max(8),
+      constraints: z.array(z.string().trim().min(1).max(500)).max(8),
+      budget: z.strictObject({ inputTokens: z.number().int().positive().safe(), outputTokens: z.number().int().positive().safe(), totalTokens: z.number().int().positive().safe() })
+    })
+  }).strict(),
+  z.object({ method: z.literal("task.review"), ...run }).strict(),
+  z.object({ method: z.literal("task.keep"), ...run, ...mutation, reviewId: z.string().uuid() }).strict(),
+  z.object({ method: z.literal("task.revise"), ...run, ...mutation, reviewId: z.string().uuid(), correction: z.string().trim().min(1).max(500) }).strict(),
+  z.object({ method: z.literal("task.continue"), ...run, ...mutation, reviewId: z.string().uuid(), prompt: z.string().trim().min(1).max(2000) }).strict(),
+  z.object({ method: z.literal("task.get"), ...run, projectionVersion: z.number().int().nonnegative().safe() }).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"),
@@ -197,12 +215,104 @@ var streamResultDocument = (result, sequence = 0) => {
   };
 };
 var serializeStreamResult = (result, sequence = 0) => JSON.stringify(streamResultDocument(result, sequence));
+// src/client/task-projection.ts
+import { z as z3 } from "zod";
+var HARNESS_TASK_PROJECTION_VERSION = 1;
+var id2 = z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var count = z3.number().int().nonnegative().safe();
+var digest = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
+var text = z3.string().max(2048);
+var tokens = z3.strictObject({ inputTokens: count, outputTokens: count, totalTokens: count });
+var harnessTaskProjectionSchema = z3.strictObject({
+  schemaVersion: z3.literal(1),
+  connectionId: id2,
+  sequence: count,
+  projectId: id2,
+  sessionId: id2,
+  runId: id2,
+  task: z3.strictObject({
+    reference: digest,
+    contractRevision: count,
+    contractDigest: digest,
+    runRevision: count,
+    objective: text.nullable(),
+    objectiveSource: z3.enum(["operator_brief", "retained_operator_source", "unavailable"]),
+    observedRunId: id2,
+    historicalRequest: z3.boolean(),
+    execution: z3.enum(["created", "queued", "running", "waiting_approval", "cancel_requested", "completed", "failed", "cancelled", "timed_out", "unknown"]),
+    artifact: z3.strictObject({
+      observedDigest: digest.nullable(),
+      deliveredDigest: digest.nullable(),
+      correspondence: z3.enum(["current", "stale", "missing"]),
+      paths: z3.array(text).max(256),
+      contents: z3.literal("not_included")
+    }),
+    review: z3.strictObject({
+      structure: z3.enum(["verified", "incomplete"]),
+      semantic: z3.literal("pending"),
+      acceptance: z3.literal("not_recorded"),
+      human: z3.array(z3.strictObject({ id: text, requirement: text, status: z3.literal("pending") })).max(32),
+      checks: z3.array(z3.strictObject({ id: text, status: z3.enum(["confirmed", "missing", "missing_or_stale", "host_policy_changed"]), provenance: z3.literal("contract_snapshot_and_tool_journal") })).max(32)
+    }),
+    budget: z3.strictObject({
+      availability: z3.enum(["authoritative", "legacy_not_enabled"]),
+      revision: count.nullable(),
+      confirmed: tokens.nullable(),
+      reserved: tokens.nullable(),
+      unknown: tokens.nullable(),
+      remaining: tokens.nullable(),
+      limits: tokens.nullable(),
+      estimated: z3.null(),
+      estimation: z3.literal("not_separately_recorded"),
+      usageComplete: z3.boolean().nullable(),
+      admissionsClosed: z3.boolean().nullable(),
+      monetary: z3.strictObject({ estimatedConfirmedUsd: z3.number().finite().nonnegative().nullable(), reservedUsd: z3.number().finite().nonnegative().nullable(), unknownHeldUsd: z3.number().finite().nonnegative().nullable(), remainingUsd: z3.number().finite().nonnegative().nullable(), unknown: z3.boolean(), costKind: z3.literal("estimate-not-invoice") })
+    }),
+    effects: z3.strictObject({ readOnly: count, recorded: count, unknown: count, missingEvidence: z3.boolean(), automaticReplay: z3.literal(false), providerStopped: z3.literal("unconfirmed") }),
+    nextAction: z3.strictObject({
+      kind: z3.enum(["wait", "reconcile", "review_approval", "review_delivery", "explicit_continuation"]),
+      permitted: z3.literal("read_only"),
+      authorization: z3.literal("required_for_execution"),
+      preserves: z3.literal("contract_receipts_budget_and_effects"),
+      automaticReplay: z3.literal(false)
+    }),
+    diagnostic: z3.strictObject({ code: z3.enum(["EXECUTION_FAILED", "EXECUTION_CANCELLED", "EXECUTION_TIMED_OUT", "EVIDENCE_INCOMPLETE"]), cause: z3.enum(["execution_terminal_failure", "operator_or_runtime_cancellation", "execution_deadline", "receipts_missing_or_stale"]), impact: z3.literal("acceptance_not_established"), safeAction: z3.enum(["review_configuration", "reconcile", "review_delivery"]) }).nullable(),
+    reasons: z3.array(z3.string().regex(/^[A-Z][A-Z0-9_]{0,95}$/)).max(32),
+    provenance: z3.literal("host_durable_contract_journal_budget_and_fresh_native_snapshot"),
+    textTruncated: z3.boolean()
+  })
+});
+function reduceHarnessTaskProjection(current, incoming, expected) {
+  const inScope = (value) => ["connectionId", "projectId", "sessionId", "runId"].every((key) => value[key] === expected[key]);
+  const previous = harnessTaskProjectionSchema.safeParse(current);
+  const retained = previous.success && inScope(previous.data) ? previous.data : null;
+  let encoded;
+  try {
+    encoded = JSON.stringify(incoming);
+  } catch {
+    return { status: "refresh_required", snapshot: retained };
+  }
+  if (new TextEncoder().encode(encoded).length > 64 * 1024)
+    return { status: "refresh_required", snapshot: retained };
+  const parsed = harnessTaskProjectionSchema.safeParse(incoming);
+  if (!parsed.success || !inScope(parsed.data))
+    return { status: "refresh_required", snapshot: retained };
+  if (retained && parsed.data.sequence <= retained.sequence) {
+    if (parsed.data.sequence === retained.sequence && JSON.stringify(parsed.data) !== JSON.stringify(retained))
+      return { status: "refresh_required", snapshot: retained };
+    return { status: "ignored", snapshot: retained };
+  }
+  return { status: "applied", snapshot: parsed.data };
+}
 export {
   CLI_EVENT_SCHEMA_VERSION,
   CLI_JSON_SCHEMA_VERSION,
   HARNESS_CLIENT_PROTOCOL_VERSION,
+  HARNESS_TASK_PROJECTION_VERSION,
   harnessClientCommandSchema,
   harnessClientRequestSchema,
+  harnessTaskProjectionSchema,
+  reduceHarnessTaskProjection,
   serializeStreamEvent,
   serializeStreamResult,
   streamEventDocument,

package/dist/engine/service.js

@@ -5,17 +5,21 @@ import {
   recoverHarnessLocalService,
   requestHarnessLocalService,
   startHarnessLocalService
-} from "../index-5jhgatga.js";
-import"../index-937cb7y8.js";
-import"../index-6dft2vev.js";
-import"../index-pp474137.js";
-import"../index-s2k2edts.js";
-import"../index-pdmevfxv.js";
-import"../index-m34q25jj.js";
-import"../index-8zjmnyw5.js";
-import"../index-m49jx72n.js";
-import"../index-xqxeypt5.js";
-import"../index-nmjdwd4p.js";
+} from "../index-crta5wzv.js";
+import"../index-02pqtbbg.js";
+import"../index-6599mpmy.js";
+import"../index-0zs2dz26.js";
+import"../index-f6mqa5gk.js";
+import"../index-dtb2c6ds.js";
+import"../index-d9zkmhz3.js";
+import"../index-1265j7t2.js";
+import"../index-c39197wq.js";
+import"../index-mzydbzp8.js";
+import"../index-wm9xeq1n.js";
+import"../index-zxg4ve4j.js";
+import"../index-4fx5f3k5.js";
+import"../index-xdbkcccf.js";
+import"../index-4gt045j0.js";
 import"../index-bpc596v3.js";
 import"../index-fm84men1.js";
 import"../index-1bx83sw4.js";