@zhivex-ai/harness 1.4.0-rc.8 → 1.4.0

package/dist/{index-txrqqd2r.js → index-937cb7y8.js}

@@ -1,6 +1,6 @@
 import {
   openWorkspaceCheckpointStore
-} from "./index-sbzvrpm7.js";
+} from "./index-6dft2vev.js";
 import {
   APPROVAL_HISTORY_KEY,
   appendUserMessage,
@@ -16,7 +16,7 @@ import {
   readApprovalDecisions,
   requiresExplicitHostReview,
   runHarness
-} from "./index-nqhnh1hz.js";
+} from "./index-pp474137.js";
 import {
   ASSISTANT_RESPONSE_KEY,
   SESSION_RUN_STATUSES,
@@ -25,21 +25,21 @@ import {
   cancelHarnessRun,
   inspectUsageLedger,
   openCliSessionStore
-} from "./index-fny13znr.js";
+} from "./index-s2k2edts.js";
 import {
   createEditProposal,
   editProposalInputSchema,
   fileDigestSchema
-} from "./index-zmx264xy.js";
+} from "./index-m34q25jj.js";
 import {
   CLI_JSON_SCHEMA_VERSION,
   harnessClientRequestSchema
-} from "./index-ngg2168h.js";
+} from "./index-nmjdwd4p.js";
 import {
   HarnessStateConflictError,
   harnessErrorDocument,
   providerStreamDiagnostic
-} from "./index-jdb1q8yn.js";
+} from "./index-bpc596v3.js";
 
 // src/client/continuation.ts
 function terminalContinuationMessages(messages) {

package/dist/{index-jdb1q8yn.js → index-bpc596v3.js}

@@ -1,3 +1,8 @@
+import {
+  classifyProviderFailure,
+  providerDiagnostic
+} from "./index-fm84men1.js";
+
 // src/runtime/errors.ts
 var HARNESS_ERROR_CODES = [
   "CONFIG_INVALID",
@@ -117,13 +122,6 @@ var harnessErrorDocument = (error) => {
     }
   };
 };
-var numericStatuses = (error) => {
-  if (!error || typeof error !== "object")
-    return;
-  const record = error;
-  const values = [record.status, record.statusCode].filter((value) => typeof value === "number" && Number.isSafeInteger(value));
-  return values.length > 0 ? values : undefined;
-};
 var normalizeHarnessError = (error) => {
   const diagnostic = providerStreamDiagnostic(error);
   if (diagnostic)
@@ -131,9 +129,16 @@ var normalizeHarnessError = (error) => {
   if (error instanceof HarnessError)
     return error;
   const message = error instanceof Error ? error.message : "Harness execution failed.";
-  const statuses = numericStatuses(error) ?? [];
-  if (statuses.some((status) => status === 429 || status >= 500 && status <= 599)) {
-    return new HarnessProviderError(message, { cause: error, retryable: true });
+  const failure = classifyProviderFailure(error);
+  if (failure.retryable) {
+    const record = error && typeof error === "object" ? error : {};
+    const body = typeof record.responseBody === "string" ? record.responseBody : typeof record.body === "string" ? record.body : undefined;
+    const providerError = new HarnessProviderError("Provider request failed.", { cause: error, retryable: true });
+    return Object.assign(providerError, {
+      ...failure.httpStatus !== undefined ? { status: failure.httpStatus } : {},
+      ...failure.providerStatus ? { providerStatus: failure.providerStatus } : {},
+      provider: providerDiagnostic(body, failure.httpStatus)
+    });
   }
   const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "";
   const code = error && typeof error === "object" && typeof error.code === "string" ? error.code : "";

package/dist/index-fm84men1.js

@@ -0,0 +1,239 @@
+// src/runtime/provider-diagnostics.ts
+import { z } from "zod";
+var providerDiagnosticSchema = z.strictObject({
+  reason: z.enum(["previous_response_unavailable", "context_length_exceeded", "authentication", "payment_required", "permission", "rate_limit", "model_unavailable", "invalid_request", "server_error", "unknown"]),
+  parameter: z.enum(["previous_response_id", "input", "messages", "tools", "model", "max_output_tokens", "max_tokens", "temperature", "other", "none"]),
+  bodyState: z.enum(["parsed", "malformed", "too_large", "unavailable", "read_timeout"])
+});
+function providerDiagnostic(body, status) {
+  let reason = status === 401 ? "authentication" : status === 402 ? "payment_required" : status === 403 ? "permission" : status === 429 ? "rate_limit" : status && status >= 500 ? "server_error" : "unknown";
+  let parameter = "none";
+  if (typeof body !== "string")
+    return { reason, parameter, bodyState: "unavailable" };
+  if (Buffer.byteLength(body) > 8192)
+    return { reason, parameter, bodyState: "too_large" };
+  try {
+    const parsed = JSON.parse(body);
+    const detail = parsed?.error ?? parsed;
+    const code = [detail?.code, detail?.status, detail?.type].find((value) => typeof value === "string") ?? "";
+    const message = typeof detail?.message === "string" ? detail.message : "";
+    const param = providerDiagnosticSchema.shape.parameter.safeParse(detail?.param);
+    parameter = param.success ? param.data : detail?.param == null ? "none" : "other";
+    if (/response/i.test(message) && /not found|expired/i.test(message) && (parameter === "previous_response_id" || parameter === "none"))
+      reason = "previous_response_unavailable";
+    else if (["context_length_exceeded", "context_window_exceeded"].includes(code))
+      reason = "context_length_exceeded";
+    else if (["invalid_api_key", "authentication_error", "UNAUTHENTICATED"].includes(code))
+      reason = "authentication";
+    else if (["permission_denied", "permission_error", "PERMISSION_DENIED"].includes(code))
+      reason = "permission";
+    else if (["rate_limit_exceeded", "rate_limit_error", "RESOURCE_EXHAUSTED"].includes(code))
+      reason = "rate_limit";
+    else if (["UNAVAILABLE", "DEADLINE_EXCEEDED", "ABORTED", "INTERNAL"].includes(code))
+      reason = "server_error";
+    else if (["model_not_found", "model_not_available", "NOT_FOUND"].includes(code))
+      reason = "model_unavailable";
+    else if (["invalid_request_error", "INVALID_ARGUMENT"].includes(code) || status === 400 || status === 422)
+      reason = "invalid_request";
+    return { reason, parameter, bodyState: "parsed" };
+  } catch {
+    return { reason, parameter, bodyState: "malformed" };
+  }
+}
+
+// src/runtime/provider-transient.ts
+var PROVIDER_STATUS_CATEGORIES = [
+  "ABORTED",
+  "RESOURCE_EXHAUSTED",
+  "UNAVAILABLE",
+  "DEADLINE_EXCEEDED",
+  "INTERNAL",
+  "STREAM_RESET"
+];
+var VERTEX_TRANSIENT_ATTEMPTS = 3;
+var TRANSIENT_HTTP = {
+  408: "DEADLINE_EXCEEDED",
+  409: "ABORTED",
+  425: "UNAVAILABLE",
+  429: "RESOURCE_EXHAUSTED",
+  500: "INTERNAL",
+  502: "UNAVAILABLE",
+  503: "UNAVAILABLE",
+  504: "DEADLINE_EXCEEDED"
+};
+var TRANSIENT_GRPC = {
+  4: "DEADLINE_EXCEEDED",
+  8: "RESOURCE_EXHAUSTED",
+  10: "ABORTED",
+  13: "INTERNAL",
+  14: "UNAVAILABLE"
+};
+var CATEGORY_HTTP = {
+  ABORTED: 409,
+  RESOURCE_EXHAUSTED: 429,
+  UNAVAILABLE: 503,
+  DEADLINE_EXCEEDED: 504,
+  INTERNAL: 500,
+  STREAM_RESET: undefined
+};
+var SYMBOLIC = new Set(["ABORTED", "RESOURCE_EXHAUSTED", "UNAVAILABLE", "DEADLINE_EXCEEDED", "INTERNAL"]);
+var STREAM_RESET_CODES = new Set(["ECONNRESET", "ECONNABORTED", "EPIPE", "ETIMEDOUT", "UND_ERR_SOCKET", "ERR_STREAM_PREMATURE_CLOSE"]);
+var HTTP_IN_MESSAGE = /(?:^|[^\d])(408|409|425|429|500|502|503|504)(?=$|[^\d])/;
+var STREAM_RESET_MESSAGE = /stream reset|RST_STREAM|ECONNRESET|socket hang up|ERR_STREAM_PREMATURE_CLOSE|UND_ERR_SOCKET/i;
+var isProviderStatus = (value) => typeof value === "string" && PROVIDER_STATUS_CATEGORIES.includes(value);
+var httpStatusValue = (value) => typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
+var definitiveClientStatus = (status) => status !== undefined && status >= 400 && status < 500 && TRANSIENT_HTTP[status] === undefined;
+function readProviderFailureRecord(record, depth = 0) {
+  let retryable = false;
+  let clientError = false;
+  let httpStatus;
+  let providerStatus;
+  const noteHttp = (status) => {
+    if (status === undefined)
+      return;
+    httpStatus ??= status;
+    const category = TRANSIENT_HTTP[status];
+    if (category) {
+      retryable = true;
+      providerStatus ??= category;
+    } else if (status >= 400 && status < 500)
+      clientError = true;
+  };
+  const noteCategory = (category) => {
+    if (!category || clientError)
+      return;
+    retryable = true;
+    providerStatus ??= category;
+    if (httpStatus === undefined)
+      httpStatus = CATEGORY_HTTP[category];
+  };
+  const absorb = (value) => {
+    if (depth >= 2 || !value || typeof value !== "object" || value === record)
+      return;
+    const signals = readProviderFailureRecord(value, depth + 1);
+    noteHttp(signals.httpStatus);
+    noteCategory(signals.providerStatus);
+  };
+  noteHttp(httpStatusValue(record.status) ?? httpStatusValue(record.statusCode) ?? httpStatusValue(record.httpStatusCode));
+  if (typeof record.status === "string" && /^\d{3}$/.test(record.status))
+    noteHttp(Number(record.status));
+  if (typeof record.code === "number" && record.code >= 100 && record.code <= 599)
+    noteHttp(record.code);
+  if (typeof record.code === "number" && record.code >= 0 && record.code <= 16)
+    noteCategory(TRANSIENT_GRPC[record.code]);
+  if (typeof record.code === "string") {
+    if (STREAM_RESET_CODES.has(record.code))
+      noteCategory("STREAM_RESET");
+    else if (SYMBOLIC.has(record.code))
+      noteCategory(record.code);
+  }
+  if (typeof record.status === "string" && SYMBOLIC.has(record.status))
+    noteCategory(record.status);
+  if (isProviderStatus(record.providerStatus))
+    noteCategory(record.providerStatus);
+  if (record.diagnosticCode === "VERTEX_STREAM_TOOL_TRUNCATED" || record.reason === "stream_truncated")
+    noteCategory("STREAM_RESET");
+  if (record.code === "PROVIDER_UNAVAILABLE" && record.retryable === true)
+    retryable = true;
+  const body = record.responseBody ?? record.body;
+  if (!clientError) {
+    if (typeof body === "string")
+      noteCategory(categoryFromBody(body));
+    else
+      absorb(body);
+    absorb(record.error);
+  }
+  if (!retryable && !clientError && typeof record.message === "string") {
+    const match = record.message.match(HTTP_IN_MESSAGE);
+    if (match?.[1])
+      noteHttp(Number(match[1]));
+    else if (STREAM_RESET_MESSAGE.test(record.message))
+      noteCategory("STREAM_RESET");
+  }
+  if (httpStatus !== undefined && definitiveClientStatus(httpStatus))
+    return { retryable: false, httpStatus };
+  return { retryable, ...httpStatus !== undefined ? { httpStatus } : {}, ...providerStatus ? { providerStatus } : {} };
+}
+function categoryFromBody(body) {
+  if (Buffer.byteLength(body) > 8192)
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    if (!parsed || typeof parsed !== "object")
+      return;
+    const detail = parsed.error;
+    const source = detail && typeof detail === "object" ? detail : parsed;
+    return readProviderFailureRecord(source).providerStatus;
+  } catch {
+    return;
+  }
+}
+function classifyProviderFailure(error) {
+  if (error && typeof error === "object") {
+    const top = readProviderFailureRecord(error);
+    if (top.httpStatus !== undefined && definitiveClientStatus(top.httpStatus))
+      return { retryable: false, httpStatus: top.httpStatus };
+  }
+  const seen = new Set;
+  let retryable = false;
+  let httpStatus;
+  let providerStatus;
+  const visit = (current, depth) => {
+    if (!current || typeof current !== "object" || depth > 5 || seen.has(current))
+      return;
+    seen.add(current);
+    const record = current;
+    const signals = readProviderFailureRecord(record);
+    httpStatus ??= signals.httpStatus;
+    providerStatus ??= signals.providerStatus;
+    if (httpStatus !== undefined && providerStatus === undefined)
+      providerStatus = TRANSIENT_HTTP[httpStatus];
+    if (record.retryable === false)
+      return;
+    if (signals.retryable)
+      retryable = true;
+    visit(record.cause, depth + 1);
+    if (record.error && typeof record.error === "object")
+      visit(record.error, depth + 1);
+    if (record.details && typeof record.details === "object")
+      visit(record.details, depth + 1);
+    if (Array.isArray(record.chain))
+      for (const entry of record.chain)
+        visit(entry, depth + 1);
+  };
+  visit(error, 0);
+  if (retryable && httpStatus === undefined && providerStatus)
+    httpStatus = CATEGORY_HTTP[providerStatus];
+  return { retryable, ...httpStatus !== undefined ? { httpStatus } : {}, ...providerStatus ? { providerStatus } : {} };
+}
+function isRetryableProviderFailure(error) {
+  return classifyProviderFailure(error).retryable;
+}
+function transientBackoffMs(attempt, baseMs = 250) {
+  const exponential = Math.min(baseMs * 2 ** Math.max(0, attempt), 1e4);
+  return exponential + Math.floor(Math.random() * exponential);
+}
+var thoughtOnlyText = (text) => {
+  try {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return false;
+    const record = parsed;
+    return record.thought === true && Object.keys(record).every((key) => key === "thought" || key === "thoughtSignature");
+  } catch {
+    return false;
+  }
+};
+function isEmptyModelTurn(result) {
+  if (result.finishReason === "content-filter" || result.finishReason === "error")
+    return false;
+  if ((result.images?.length ?? 0) > 0 || (result.audio?.length ?? 0) > 0)
+    return false;
+  const parts = result.messages?.flatMap((message) => message.parts ?? []) ?? [];
+  if (parts.some((part) => part.type === "tool-call" || part.type === "image" || part.type === "audio"))
+    return false;
+  const texts = [result.text ?? "", ...parts.filter((part) => part.type === "text").map((part) => part.text ?? "")];
+  return texts.every((text) => text.trim().length === 0 || thoughtOnlyText(text.trim()));
+}
+
+export { providerDiagnosticSchema, providerDiagnostic, PROVIDER_STATUS_CATEGORIES, VERTEX_TRANSIENT_ATTEMPTS, readProviderFailureRecord, classifyProviderFailure, isRetryableProviderFailure, transientBackoffMs, isEmptyModelTurn };

package/dist/{index-zmx264xy.js → index-m34q25jj.js}

@@ -1,12 +1,12 @@
 import {
   HARNESS_EXECUTION_POLICY_VERSION
-} from "./index-09zphhwt.js";
+} from "./index-8zjmnyw5.js";
 import {
   HarnessError,
   HarnessExecutionError,
   HarnessStateConflictError,
   HarnessWorkspaceError
-} from "./index-jdb1q8yn.js";
+} from "./index-bpc596v3.js";
 
 // src/workspace/edit-contracts.ts
 import { createHash } from "node:crypto";

package/dist/index-m49jx72n.js

@@ -0,0 +1,220 @@
+import {
+  VERTEX_TRANSIENT_ATTEMPTS,
+  classifyProviderFailure,
+  isEmptyModelTurn,
+  isRetryableProviderFailure,
+  providerDiagnostic,
+  providerDiagnosticSchema,
+  transientBackoffMs
+} from "./index-fm84men1.js";
+
+// src/providers/vertex-auth.ts
+import { GoogleAuth } from "google-auth-library";
+import { createVertex } from "@zhivex-ai/vertex";
+import { wrapLanguageModel } from "@zhivex-ai/core";
+var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+function vertexRoute(env) {
+  const projectId = (env.GOOGLE_CLOUD_PROJECT ?? "").trim();
+  const location = (env.VERTEX_LOCATION ?? "").trim();
+  if (!/^(?:[a-z][a-z0-9-]{4,61}[a-z0-9]|[0-9]{6,20})$/.test(projectId)) {
+    throw new Error("Vertex requires a valid GOOGLE_CLOUD_PROJECT.");
+  }
+  if (!/^(?:global|us|eu|[a-z]+-[a-z]+[0-9]+)$/.test(location)) {
+    throw new Error("Vertex requires an explicit valid VERTEX_LOCATION.");
+  }
+  return Object.freeze({ projectId, location });
+}
+function vertexConfigured(env) {
+  try {
+    vertexRoute(env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VERTEX_ENVIRONMENT = ["GOOGLE_CLOUD_PROJECT", "VERTEX_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"];
+function vertexEnvironment(env) {
+  return Object.fromEntries(VERTEX_ENVIRONMENT.flatMap((name) => env[name] ? [[name, env[name]]] : []));
+}
+function vertexTokenSource(env, route, createAuth = (options) => new GoogleAuth(options)) {
+  const keyFilename = env.GOOGLE_APPLICATION_CREDENTIALS?.trim();
+  const auth = createAuth({
+    projectId: route.projectId,
+    scopes: [CLOUD_PLATFORM_SCOPE],
+    ...keyFilename ? { keyFilename } : {}
+  });
+  return async () => {
+    try {
+      const token = await auth.getAccessToken();
+      if (!token)
+        throw new Error("Empty ADC token");
+      return token;
+    } catch {
+      throw new VertexAuthenticationError;
+    }
+  };
+}
+
+class VertexAuthenticationError extends Error {
+  status = 401;
+  retryable = false;
+  constructor() {
+    super("Vertex ADC credentials are unavailable or could not be refreshed. Configure Application Default Credentials and retry.");
+    this.name = "VertexAuthenticationError";
+  }
+}
+function createVertexModel(model, env, createAuth, retry) {
+  const route = vertexRoute(env);
+  const adapter = createVertex({
+    ...route,
+    getAccessToken: vertexTokenSource(env, route, createAuth)
+  })(model);
+  const attempts = retry?.attempts ?? VERTEX_TRANSIENT_ATTEMPTS;
+  const delayFor = (input) => retry?.delayMs ?? ((attempt) => input.retryBackoffMs === 0 ? 0 : transientBackoffMs(attempt, input.retryBackoffMs ?? 250));
+  const generate = async (input) => withVertexAttempts(input.abortSignal, vertexAttemptBudget(input, attempts), delayFor(input), async () => {
+    try {
+      return await adapter.generate({ ...input, maxRetries: 0 });
+    } catch (error) {
+      throw safeVertexError(error);
+    }
+  }, (result) => !isEmptyModelTurn(result));
+  const innerStream = adapter.stream?.bind(adapter);
+  const retrying = innerStream ? {
+    ...adapter,
+    generate,
+    async stream(input) {
+      const events = await withVertexAttempts(input.abortSignal, vertexAttemptBudget(input, attempts), delayFor(input), () => collectVertexStream(() => innerStream({ ...input, maxRetries: 0 })), (events2) => !isEmptyVertexStream(events2));
+      return replayVertexStream(events);
+    }
+  } : { ...adapter, generate };
+  return wrapLanguageModel(retrying, [{
+    name: "harness-vertex-sanitized-errors",
+    async wrapGenerate(_context, next) {
+      try {
+        return await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+    },
+    async wrapStream(_context, next) {
+      let stream;
+      try {
+        stream = await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+      return async function* () {
+        try {
+          yield* stream;
+        } catch (error) {
+          throw safeVertexError(error);
+        }
+      }();
+    }
+  }]);
+}
+async function collectVertexStream(next) {
+  let stream;
+  try {
+    stream = await next();
+  } catch (error) {
+    throw safeVertexError(error);
+  }
+  const events = [];
+  try {
+    for await (const event of stream) {
+      if (event.type === "error")
+        throw safeVertexError(event.error);
+      events.push(event);
+    }
+  } catch (error) {
+    throw error instanceof Error && error.message.startsWith("Vertex request failed.") ? error : safeVertexError(error);
+  }
+  return events;
+}
+function isEmptyVertexStream(events) {
+  let text = "";
+  let finishReason;
+  let tools = false;
+  let media = false;
+  for (const event of events) {
+    if (event.type === "text-delta")
+      text += event.textDelta;
+    else if (event.type === "tool-call" || event.type === "tool-approval-request")
+      tools = true;
+    else if (event.type === "image-generation")
+      media = true;
+    else if (event.type === "finish")
+      finishReason = event.finishReason;
+  }
+  return isEmptyModelTurn({
+    text,
+    finishReason,
+    ...tools ? { messages: [{ parts: [{ type: "tool-call" }] }] } : {},
+    ...media ? { images: [{}] } : {}
+  });
+}
+function replayVertexStream(events) {
+  return async function* () {
+    yield* events;
+  }();
+}
+async function withVertexAttempts(abortSignal, attempts, delayMs, run, accept) {
+  let last;
+  for (let attempt = 0;attempt < attempts; attempt += 1) {
+    if (abortSignal?.aborted)
+      throw new DOMException("Vertex request cancelled.", "AbortError");
+    try {
+      const value = await run();
+      if (accept(value) || attempt === attempts - 1)
+        return value;
+      last = value;
+    } catch (error) {
+      const safe = error instanceof Error && (error.name === "AbortError" || error.message.startsWith("Vertex request failed.")) ? error : safeVertexError(error);
+      if (safe.name === "AbortError" || abortSignal?.aborted || attempt === attempts - 1 || !isRetryableProviderFailure(safe))
+        throw safe;
+    }
+    await sleep(delayMs(attempt));
+  }
+  return last;
+}
+var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+function vertexAttemptBudget(input, fallback) {
+  const requested = [
+    typeof input.maxProviderRequests === "number" ? input.maxProviderRequests : undefined,
+    typeof input.maxRetries === "number" ? input.maxRetries + 1 : undefined
+  ].filter((value) => value !== undefined);
+  if (requested.length === 0)
+    return Math.max(1, fallback);
+  return Math.max(1, Math.min(...requested));
+}
+function safeVertexError(error) {
+  if (error instanceof VertexAuthenticationError)
+    return error;
+  const record = error && typeof error === "object" ? error : {};
+  if (record.name === "AbortError")
+    return new DOMException("Vertex request cancelled.", "AbortError");
+  const failure = classifyProviderFailure(error);
+  const body = providerBody(record.responseBody) ?? providerBody(record.body);
+  const preserved = providerDiagnosticSchema.safeParse(record.provider);
+  const provider = body !== undefined ? providerDiagnostic(body, failure.httpStatus) : preserved.success ? preserved.data : providerDiagnostic(undefined, failure.httpStatus);
+  return Object.assign(new Error("Vertex request failed. Check the sanitized provider diagnosis."), {
+    ...failure.httpStatus !== undefined ? { status: failure.httpStatus } : {},
+    ...failure.providerStatus ? { providerStatus: failure.providerStatus } : {},
+    provider,
+    retryable: failure.retryable
+  });
+}
+function providerBody(value) {
+  if (typeof value === "string")
+    return value;
+  if (!value || typeof value !== "object")
+    return;
+  try {
+    return JSON.stringify(value).slice(0, 8192);
+  } catch {
+    return;
+  }
+}
+
+export { vertexRoute, vertexConfigured, VERTEX_ENVIRONMENT, vertexEnvironment, vertexTokenSource, createVertexModel };

package/dist/{index-9v72fpya.js → index-m82cfspw.js}

@@ -1,23 +1,25 @@
 import {
   fileDigestSchema
-} from "./index-zmx264xy.js";
+} from "./index-m34q25jj.js";
 import {
   PROVIDERS,
   reasoningEffortSchema
-} from "./index-09zphhwt.js";
-import {
-  providerDiagnostic,
-  providerDiagnosticSchema
-} from "./index-8705zxpr.js";
+} from "./index-8zjmnyw5.js";
 import {
   CLI_EVENT_SCHEMA_VERSION,
   CLI_JSON_SCHEMA_VERSION
-} from "./index-ngg2168h.js";
+} from "./index-nmjdwd4p.js";
 import {
   HARNESS_ERROR_CODES,
   HARNESS_ERROR_SCHEMA_VERSION,
   HarnessError
-} from "./index-jdb1q8yn.js";
+} from "./index-bpc596v3.js";
+import {
+  PROVIDER_STATUS_CATEGORIES,
+  providerDiagnostic,
+  providerDiagnosticSchema,
+  readProviderFailureRecord
+} from "./index-fm84men1.js";
 
 // src/workspace/change-envelope.ts
 import { createHash } from "node:crypto";
@@ -1245,6 +1247,7 @@ var errorDetailsSchema = z3.strictObject({
     checkpoint: z3.enum(checkpoints).optional(),
     code: z3.enum([...HARNESS_ERROR_CODES, ...systemCodes]).optional(),
     provider: providerDiagnosticSchema.optional(),
+    providerStatus: z3.enum(PROVIDER_STATUS_CATEGORIES).optional(),
     status: z3.number().int().min(100).max(599).optional(),
     retryable: z3.boolean().optional(),
     acceptanceReason: z3.enum(acceptanceReasons).optional(),
@@ -1335,11 +1338,14 @@ var sanitizedErrorDetails = (error) => {
     const allowedCodes = [...HARNESS_ERROR_CODES, ...systemCodes];
     if (allowedCodes.includes(record.code))
       entry.code = record.code;
-    const status = [record.status, record.statusCode].find((value) => typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599);
+    const signals = readProviderFailureRecord(record);
+    const status = [record.status, record.statusCode, record.httpStatusCode, signals.httpStatus].find((value) => typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599);
     if (typeof status === "number") {
       entry.status = status;
-      entry.provider = providerDiagnostic(record.responseBody ?? record.body, status);
+      entry.provider = providerDiagnostic(typeof record.responseBody === "string" || typeof record.body === "string" ? record.responseBody ?? record.body : undefined, status);
     }
+    if (signals.providerStatus)
+      entry.providerStatus = signals.providerStatus;
     const provider = providerDiagnosticSchema.safeParse(record.provider);
     if (provider.success)
       entry.provider = provider.data;

package/dist/{index-ngg2168h.js → index-nmjdwd4p.js}

@@ -1,6 +1,6 @@
 import {
   providerStreamDiagnostic
-} from "./index-jdb1q8yn.js";
+} from "./index-bpc596v3.js";
 
 // src/client/stream.ts
 var CLI_JSON_SCHEMA_VERSION = 1;

package/dist/{index-w9pjt7td.js → index-pdmevfxv.js}

@@ -1,17 +1,17 @@
 import {
   readRegularFileNoFollow
-} from "./index-zmx264xy.js";
+} from "./index-m34q25jj.js";
 import {
   HarnessConfigError,
   HarnessError,
   HarnessExecutionError,
   HarnessProviderError,
   HarnessWorkspaceError
-} from "./index-jdb1q8yn.js";
+} from "./index-bpc596v3.js";
 // package.json
 var package_default = {
   name: "@zhivex-ai/harness",
-  version: "1.4.0-rc.8",
+  version: "1.4.0",
   description: "Governed, provider-portable runtime for coding agents with durable approvals and isolated repository execution.",
   type: "module",
   license: "MIT",