chainlesschain 0.166.77 → 0.166.79

package/src/lib/evolution/evolution-eval-cohort-receipt-reconciliation.js

@@ -0,0 +1,389 @@
+/** Join a sealed admission inventory to presented final Eval receipts.
+ * Missing receipts stay unresolved; a caller-supplied set cannot prove global coverage.
+ */
+import { createHash } from "node:crypto";
+import { isProxy } from "node:util/types";
+import {
+  resolveEvolutionEvalCohortEnrollment,
+  resolveEvolutionEvalCohortReconciliation,
+} from "./evolution-eval-cohort-enrollment.js";
+import {
+  computeEvolutionEvalContextDigest,
+  computeEvolutionEvalLaunchRequestDigest,
+  isEvolutionEvalReceiptVerifier,
+  verifyEvolutionEvalReceipt,
+} from "./evolution-eval-gate.js";
+import { verifyPmExplorationEffectAttemptCohort } from "./pm-exploration-benchmark.js";
+
+export const EVOLUTION_EVAL_COHORT_RECEIPT_RECONCILIATION_SCHEMA =
+  "chainlesschain.evolution-eval-cohort-receipt-reconciliation/v1";
+export const EVOLUTION_EVAL_COHORT_RECEIPT_RECONCILIATION_FAILED_CODE =
+  "CC_EVOLUTION_EVAL_COHORT_RECEIPT_RECONCILIATION_FAILED";
+export const PM_EXPLORATION_ADMISSION_BOUND_COHORT_SCHEMA =
+  "chainlesschain.pm-exploration-admission-bound-cohort/v1";
+
+function fail(message) {
+  const error = new Error(message);
+  error.code = EVOLUTION_EVAL_COHORT_RECEIPT_RECONCILIATION_FAILED_CODE;
+  throw error;
+}
+
+function snapshot(value, budget = { nodes: 0, chars: 0 }, depth = 0) {
+  if (++budget.nodes > 50_000 || depth > 50)
+    fail("cohort receipt evidence exceeds structural limits");
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    budget.chars += value.length;
+    if (budget.chars > 4_000_000)
+      fail("cohort receipt evidence exceeds size limit");
+    return value;
+  }
+  if (!value || typeof value !== "object" || isProxy(value))
+    fail("cohort receipt evidence must contain plain JSON data");
+  if (Array.isArray(value)) {
+    if (
+      Object.getPrototypeOf(value) !== Array.prototype ||
+      Reflect.ownKeys(value).length !== value.length + 1
+    )
+      fail("cohort receipt array must be dense own data");
+    return Array.from({ length: value.length }, (_, index) => {
+      const property = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!property || !("value" in property))
+        fail("cohort receipt array must be own data");
+      return snapshot(property.value, budget, depth + 1);
+    });
+  }
+  if (![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    fail("cohort receipt evidence must be plain data");
+  return Object.fromEntries(
+    Reflect.ownKeys(value).map((key) => {
+      const property = Object.getOwnPropertyDescriptor(value, key);
+      if (
+        typeof key !== "string" ||
+        !property?.enumerable ||
+        !("value" in property)
+      )
+        fail("cohort receipt fields must be own data");
+      budget.chars += key.length;
+      if (budget.chars > 4_000_000)
+        fail("cohort receipt evidence exceeds size limit");
+      return [key, snapshot(property.value, budget, depth + 1)];
+    }),
+  );
+}
+
+function exact(value, keys, label) {
+  if (
+    !value ||
+    Array.isArray(value) ||
+    typeof value !== "object" ||
+    Reflect.ownKeys(value).length !== keys.length ||
+    keys.some((key) => !Object.hasOwn(value, key))
+  )
+    fail(`${label} must contain exactly its registered fields`);
+  return value;
+}
+
+function captureRecord(value, keys, label) {
+  if (
+    !value ||
+    Array.isArray(value) ||
+    typeof value !== "object" ||
+    isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value)) ||
+    Reflect.ownKeys(value).length !== keys.length
+  )
+    fail(`${label} must contain exactly its own data fields`);
+  return Object.fromEntries(
+    keys.map((key) => {
+      const property = Object.getOwnPropertyDescriptor(value, key);
+      if (!property?.enumerable || !("value" in property))
+        fail(`${label} must contain exactly its own data fields`);
+      return [key, property.value];
+    }),
+  );
+}
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+function hash(
+  value,
+  schema = EVOLUTION_EVAL_COHORT_RECEIPT_RECONCILIATION_SCHEMA,
+) {
+  return `sha256:${createHash("sha256")
+    .update(`${schema}\0${canonical(value)}`)
+    .digest("hex")}`;
+}
+
+function frozen(value) {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value)) frozen(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/** Re-audit the sealed admission set after signature checks. */
+export async function reconcileEvolutionEvalCohortReceipts(
+  authority,
+  verifier,
+  input,
+) {
+  if (!isEvolutionEvalReceiptVerifier(verifier))
+    fail("a branded final Eval receipt verifier is required");
+  const source = exact(
+    snapshot(input),
+    ["cohortId", "slots"],
+    "cohort receipt source",
+  );
+  if (
+    typeof source.cohortId !== "string" ||
+    !Array.isArray(source.slots) ||
+    source.slots.length > 32
+  )
+    fail("cohort receipt slots are invalid");
+  const lookup = { cohortId: source.cohortId };
+  const enrollment = resolveEvolutionEvalCohortEnrollment(authority, lookup);
+  const sealed = await resolveEvolutionEvalCohortReconciliation(
+    authority,
+    lookup,
+  );
+  if (source.slots.length !== enrollment.evidence.slots.length)
+    fail("cohort receipt source must cover every enrolled slot");
+  const admitted = new Map(
+    sealed.inventory.admissions.map((entry) => [entry.slotId, entry]),
+  );
+  const slots = [];
+  let signedReceiptCount = 0;
+  let receiptUnavailableCount = 0;
+  for (const [index, item] of source.slots.entries()) {
+    const entry = exact(
+      item,
+      ["slotId", "launchRequest", "receipt", "receiptContext"],
+      "cohort receipt slot",
+    );
+    const registered = enrollment.evidence.slots[index];
+    if (entry.slotId !== registered.slotId)
+      fail("cohort receipt slots differ from enrolled order");
+    const admission = admitted.get(entry.slotId);
+    if (entry.receipt === null) {
+      if (entry.launchRequest !== null || entry.receiptContext !== null)
+        fail("missing receipt cannot carry a substituted source");
+      if (admission) receiptUnavailableCount += 1;
+      slots.push({
+        slotId: entry.slotId,
+        status: admission ? "receipt-unavailable" : "unadmitted",
+        admissionDigest: admission?.admissionDigest ?? null,
+        runId: admission?.runId ?? null,
+        receiptDigest: null,
+        decision: null,
+      });
+      continue;
+    }
+    if (!admission || !entry.launchRequest || !entry.receiptContext)
+      fail("signed receipt has no matching admitted slot or context");
+    const request = exact(
+      entry.launchRequest,
+      [
+        "suiteRef",
+        "candidateId",
+        "baselineId",
+        "targetEnvironmentRef",
+        "evaluationContext",
+      ],
+      "cohort launch request",
+    );
+    const context = exact(
+      entry.receiptContext,
+      [
+        "runId",
+        "runNonce",
+        "suiteDigest",
+        "policyDigest",
+        "evaluationAuthorityRoot",
+        "targetEnvironmentRef",
+        "evaluationContextDigest",
+        "candidateId",
+        "baselineId",
+        "environmentDigest",
+        "tenantId",
+        "provenanceAudience",
+        "trainerAuthority",
+        "trainerRevision",
+      ],
+      "cohort receipt context",
+    );
+    const run = exact(
+      request.evaluationContext,
+      ["planDigest", "targetMatrixRoot", "cellId", "runtimeId"],
+      "cohort evaluation context",
+    );
+    if (
+      computeEvolutionEvalLaunchRequestDigest(request) !==
+        admission.requestDigest ||
+      run.planDigest !== registered.evaluationPlanDigest ||
+      run.cellId !== entry.slotId ||
+      request.candidateId !== context.candidateId ||
+      request.baselineId !== context.baselineId ||
+      request.targetEnvironmentRef !== context.targetEnvironmentRef ||
+      context.runId !== admission.runId ||
+      context.runNonce !== admission.runNonce ||
+      context.tenantId !== enrollment.evidence.descriptor.tenantId ||
+      context.policyDigest !== registered.policyDigest ||
+      context.evaluationAuthorityRoot !== registered.evaluationAuthorityRoot ||
+      context.evaluationContextDigest !==
+        computeEvolutionEvalContextDigest({
+          ...run,
+          tenantId: context.tenantId,
+          targetEnvironmentRef: context.targetEnvironmentRef,
+          environmentDigest: context.environmentDigest,
+          candidateId: context.candidateId,
+          baselineId: context.baselineId,
+          suiteDigest: context.suiteDigest,
+          policyDigest: context.policyDigest,
+          evaluationAuthorityRoot: context.evaluationAuthorityRoot,
+        })
+    )
+      fail("signed receipt differs from admitted request or enrolled cell");
+    const verified = await verifyEvolutionEvalReceipt(
+      verifier,
+      entry.receipt,
+      context,
+    );
+    signedReceiptCount += 1;
+    slots.push({
+      slotId: entry.slotId,
+      status: "signed-receipt",
+      admissionDigest: admission.admissionDigest,
+      runId: admission.runId,
+      receiptDigest: verified.receiptDigest,
+      decision: verified.decision,
+    });
+  }
+  const finalSeal = await resolveEvolutionEvalCohortReconciliation(
+    authority,
+    lookup,
+  );
+  if (canonical(finalSeal) !== canonical(sealed))
+    fail("sealed Ledger inventory changed during receipt verification");
+  const core = {
+    schema: EVOLUTION_EVAL_COHORT_RECEIPT_RECONCILIATION_SCHEMA,
+    cohortId: source.cohortId,
+    enrollmentDigest: sealed.enrollmentDigest,
+    sealDigest: sealed.sealDigest,
+    admissionInventoryAuthenticated: true,
+    signedReceiptCount,
+    receiptUnavailableCount,
+    unadmittedSlotCount: sealed.inventory.unadmittedSlotIds.length,
+    slots,
+    presentedReceiptsAuthenticated: true,
+    receiptSetCompletenessAuthenticated: false,
+    executionCoverageAuthenticated: false,
+    cohortCompletenessAuthenticated: false,
+    promotionAuthority: false,
+  };
+  return frozen({ ...core, reconciliationDigest: hash(core) });
+}
+
+/** Bind the independently verified PM denominator to the signed admission/receipt census. */
+export async function reconcilePmExplorationAdmissionBoundCohort(
+  authority,
+  verifier,
+  input,
+) {
+  if (!isEvolutionEvalReceiptVerifier(verifier))
+    fail("a branded final Eval receipt verifier is required");
+  const source = captureRecord(
+    input,
+    ["cohortId", "receiptSlots", "cohortSource", "cohort", "registration"],
+    "PM admission-bound cohort source",
+  );
+  const receiptSlots = snapshot(source.receiptSlots);
+  const registration = exact(
+    snapshot(source.registration),
+    ["cohortId", "planDigest", "slots"],
+    "PM cohort registration",
+  );
+  // This verifier snapshots its source and expected context before its first await.
+  const pm = await verifyPmExplorationEffectAttemptCohort(
+    verifier,
+    { source: source.cohortSource, cohort: source.cohort },
+    registration,
+  );
+  const joined = await reconcileEvolutionEvalCohortReceipts(
+    authority,
+    verifier,
+    { cohortId: source.cohortId, slots: receiptSlots },
+  );
+  const enrollment = resolveEvolutionEvalCohortEnrollment(authority, {
+    cohortId: source.cohortId,
+  });
+  if (
+    pm.cohortId !== source.cohortId ||
+    registration.cohortId !== source.cohortId ||
+    pm.planDigest !== enrollment.evidence.plan.planDigest ||
+    registration.planDigest !== pm.planDigest ||
+    pm.registeredSlotCount !== enrollment.evidence.manifest.slotIds.length ||
+    pm.perArmDenominator !==
+      enrollment.evidence.manifest.plannedTestObservationsPerArm ||
+    canonical(registration.slots.map((slot) => slot.slotId)) !==
+      canonical(enrollment.evidence.manifest.slotIds)
+  )
+    fail("PM denominator differs from signed cohort enrollment");
+  for (const [index, attempt] of pm.attempts.entries()) {
+    const admitted = joined.slots[index];
+    if (
+      attempt.slotId !== admitted.slotId ||
+      (admitted.status === "signed-receipt" &&
+        (attempt.kind === "receipt-unavailable" ||
+          attempt.runId !== admitted.runId ||
+          attempt.receiptDigest !== admitted.receiptDigest)) ||
+      (admitted.status !== "signed-receipt" &&
+        (attempt.kind !== "receipt-unavailable" ||
+          attempt.runId !== null ||
+          attempt.receiptDigest !== null))
+    )
+      fail("PM attempt differs from its sealed admission and final receipt");
+  }
+  if (
+    pm.authenticatedAttemptCount !== joined.signedReceiptCount ||
+    (pm.missingReceiptCount ?? 0) !==
+      joined.receiptUnavailableCount + joined.unadmittedSlotCount
+  )
+    fail("PM attempt counts differ from sealed admission inventory");
+  const core = {
+    schema: PM_EXPLORATION_ADMISSION_BOUND_COHORT_SCHEMA,
+    cohortId: source.cohortId,
+    planDigest: pm.planDigest,
+    enrollmentDigest: joined.enrollmentDigest,
+    sealDigest: joined.sealDigest,
+    receiptReconciliationDigest: joined.reconciliationDigest,
+    attemptCohortDigest: pm.cohortDigest,
+    registeredSlotCount: pm.registeredSlotCount,
+    signedReceiptCount: joined.signedReceiptCount,
+    admittedMissingReceiptCount: joined.receiptUnavailableCount,
+    unadmittedSlotCount: joined.unadmittedSlotCount,
+    perArmDenominator: pm.perArmDenominator,
+    baseline: pm.baseline,
+    candidate: pm.candidate,
+    admissionAndAttemptBindingAuthenticated: true,
+    receiptSetCompletenessAuthenticated: false,
+    executionCoverageAuthenticated: false,
+    cohortCompletenessAuthenticated: false,
+    reportAuthenticated: false,
+    requiresIndependentPilotApproval: true,
+    qualifiesForPromotion: false,
+  };
+  return frozen({
+    ...core,
+    bindingDigest: hash(core, PM_EXPLORATION_ADMISSION_BOUND_COHORT_SCHEMA),
+  });
+}

package/src/lib/execution-location-failure-site.js

@@ -0,0 +1,63 @@
+// Diagnostic locations are public source labels, never target paths, stack
+// text or error messages. They do not grant authority or trigger a retry.
+const SOURCES = Object.freeze({
+  "commands/session-location.js": "session-location",
+  "harness/jsonl-session-store.js": "session-store",
+  "harness/session-index.js": "session-index",
+  "harness/transcript-integrity.js": "transcript-integrity",
+  "lib/secure-fs.js": "private-storage",
+  "lib/secure-file-identity.js": "file-identity",
+  "lib/session-anti-rollback-anchor.js": "session-anchor",
+  "lib/with-file-lock.js": "file-lock",
+  "lib/execution-location-local-supervisor.mjs": "local-supervisor",
+  "lib/execution-location-contract.js": "location-contract",
+});
+const LABELS = new Set(Object.values(SOURCES));
+const PREFIX = "CC_EXECUTION_LOCATION_FAILURE_SITE=";
+const MAX_DIAGNOSTIC_CHARS = 8192;
+
+// PowerShell diagnostics are deliberately bounded to fixed native operation
+// labels and HRESULTs; neither paths nor exception text cross the boundary.
+export function readExecutionLocationStorageFailure(stderr) {
+  const match = String(stderr || "")
+    .slice(0, MAX_DIAGNOSTIC_CHARS)
+    .match(
+      /\[windows-acl:(initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify|timeout(?:-(?:startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify))?|spawn|output)(:0x[0-9a-f]{8})?\]/u,
+    );
+  return match ? `${match[1]}${match[2] || ""}` : null;
+}
+
+export function executionLocationFailureSite(error) {
+  const stack = String(error?.stack || "").slice(0, MAX_DIAGNOSTIC_CHARS);
+  for (const frame of stack.split(/\r?\n/u).slice(1)) {
+    if (!/^\s+at /u.test(frame)) continue;
+    const normalized = frame.replaceAll("\\", "/");
+    for (const [source, label] of Object.entries(SOURCES)) {
+      const suffix = `/packages/cli/src/${source}:`;
+      const index = normalized.lastIndexOf(suffix);
+      if (index < 0) continue;
+      const position = normalized.slice(index + suffix.length);
+      const line = position.match(/^([1-9][0-9]{0,5}):[0-9]+\)?$/u)?.[1];
+      if (line) return `${label}:${line}`;
+    }
+  }
+  return null;
+}
+
+export function formatExecutionLocationFailureSite(error) {
+  const site = executionLocationFailureSite(error);
+  return site === null ? "" : `${PREFIX}${site}\n`;
+}
+
+export function readExecutionLocationFailureSite(stderr) {
+  const text = String(stderr || "").slice(0, MAX_DIAGNOSTIC_CHARS);
+  for (const line of text.split(/\r?\n/u)) {
+    if (!line.startsWith(PREFIX)) continue;
+    const match = line
+      .slice(PREFIX.length)
+      .match(/^([a-z-]+):([1-9][0-9]{0,5})$/u);
+    if (match && LABELS.has(match[1])) return `${match[1]}:${match[2]}`;
+  }
+  // An uncaught supervisor exception already has a stack on stderr.
+  return executionLocationFailureSite({ stack: text });
+}

package/src/lib/execution-location-target.js

@@ -4,6 +4,10 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { TextDecoder } from "node:util";
+import {
+  readExecutionLocationFailureSite,
+  readExecutionLocationStorageFailure,
+} from "./execution-location-failure-site.js";
 import {
   EXECUTION_LOCATION_TARGET_ATTESTATION_SCHEMA,
   createExecutionLocationTargetAttestation,
@@ -18,7 +22,11 @@ import {
 import { canonicalJson } from "./scheduler-kernel/contract.js";
 import { executionBroker } from "./process-execution-broker/index.js";
 import { assertExecutionLocationRunnerLeaseAuthority } from "./execution-location-runner-lifecycle.js";
-import { ensurePrivateDirectory, repairPrivatePaths } from "./secure-fs.js";
+import {
+  _resolveWindowsAclTimeout,
+  ensurePrivateDirectory,
+  repairPrivatePaths,
+} from "./secure-fs.js";
 import { getSessionAntiRollbackDirectory } from "./session-anti-rollback-anchor.js";
 import {
   MAX_EXECUTION_LOCATION_RESULT_BUNDLE_BYTES,
@@ -657,6 +665,11 @@ function localTargetEnvironment(profile, lifecycleEnvironment) {
     // Windows. Keep all CLI state beneath a dedicated child directory.
     CHAINLESSCHAIN_HOME: path.join(profile.transport.home, ".chainlesschain"),
     CHAINLESSCHAIN_SECURITY_ANCHOR_HOME: profile.transport.securityHome,
+    // This numeric, bounded operation allowance is part of local storage
+    // configuration. Forward no other caller-specific environment or secrets.
+    CC_SECURE_FS_WINDOWS_ACL_TIMEOUT_MS: String(
+      _resolveWindowsAclTimeout(15_000),
+    ),
     FORCE_COLOR: "0",
     HOME: profile.transport.home,
     LOCALAPPDATA: path.join(profile.transport.home, "AppData", "Local"),
@@ -706,6 +719,7 @@ export function prepareLocalTargetState(profile, cliArgs, deps = {}) {
     anchorBase: profile.transport.securityHome,
   });
   const sessionDigest = createHash("sha256").update(sessionId).digest("hex");
+  const platform = deps.platform || process.platform;
   const directories = [
     stateHome,
     path.join(stateHome, "sessions"),
@@ -715,11 +729,19 @@ export function prepareLocalTargetState(profile, cliArgs, deps = {}) {
     path.join(antiRollbackDirectory, "namespace"),
     path.join(antiRollbackDirectory, "records"),
     path.join(antiRollbackDirectory, "records", sessionDigest.slice(0, 2)),
+    // Windows known-folder APIs can return an empty path for nonexistent
+    // isolated profile directories, making first-use caches relative to cwd.
+    ...(platform === "win32"
+      ? [
+          path.join(profile.transport.home, "AppData"),
+          path.join(profile.transport.home, "AppData", "Local"),
+          path.join(profile.transport.home, "AppData", "Roaming"),
+        ]
+      : []),
   ];
   const uniqueDirectories = [...new Set(directories)];
   const ensure = deps.ensurePrivateDirectory || ensurePrivateDirectory;
   const repair = deps.repairPrivatePaths || repairPrivatePaths;
-  const platform = deps.platform || process.platform;
   for (const directory of uniqueDirectories) {
     ensure(
       directory,
@@ -961,6 +983,65 @@ function targetInvocation(profile, cliArgs, deps = {}, options = {}) {
   });
 }
 
+// Target output can contain session text, paths, or credentials. Report only
+// a fixed diagnostic category; this is never an authorization/retry decision.
+function targetCommandFailureCategory(result) {
+  const stderr = String(result?.stderr || "").slice(0, MAX_PROBE_BYTES);
+  if (readExecutionLocationStorageFailure(stderr)) return "windows-acl";
+  const categories = [
+    ["stdin-empty", /session replica stdin is empty/u],
+    ["stdin-read-unavailable", /(?:EAGAIN|EINVAL)[^\r\n]*read/u],
+    ["stdin-identity", /local target stdin file (?:is invalid|changed)/u],
+    [
+      "target-facts-changed",
+      /target facts changed before location handoff append/u,
+    ],
+    ["filesystem-access", /\b(?:EACCES|EPERM)\b|Access is denied/iu],
+    ["filesystem-missing", /\bENOENT\b/u],
+    ["module-load", /\b(?:ERR_MODULE_NOT_FOUND|MODULE_NOT_FOUND)\b/u],
+    [
+      "file-identity",
+      /(?:identity changed|pathname and descriptor identities differ|physical, non-symlink|single-link file)/u,
+    ],
+    [
+      "storage-integrity",
+      /(?:[Aa]nti-rollback|[Tt]ranscript digest|[Hh]ash chain|[Aa]nchor|[Rr]eplica)[^\r\n]*(?:invalid|mismatch|failed|conflict)/u,
+    ],
+    [
+      "deployment-authority",
+      /(?:authenticated evolution ingress|evolution deployment)/u,
+    ],
+    ["memory-limit", /heap out of memory|Reached heap limit/iu],
+  ];
+  return (
+    categories.find(([, pattern]) => pattern.test(stderr))?.[0] || "unknown"
+  );
+}
+
+function targetProcessFailure(result) {
+  // Native spawn errors include executable paths and argv. Preserve only fixed
+  // categories and the same content-free diagnostics as a nonzero target exit.
+  // A timeout is an unknown outcome: this function never retries the command.
+  const categories = new Map([
+    ["ETIMEDOUT", "process-timeout"],
+    ["ENOBUFS", "process-output-limit"],
+    ["ENOENT", "process-unavailable"],
+    ["EACCES", "process-access"],
+    ["EPERM", "process-access"],
+  ]);
+  const failureCategory = categories.get(result.error.code) || "process-spawn";
+  const failureSite = readExecutionLocationFailureSite(result.stderr);
+  const storageFailure = readExecutionLocationStorageFailure(result.stderr);
+  const error = new Error(
+    `target process failed (${failureCategory})${failureSite ? ` at ${failureSite}` : ""}${storageFailure ? ` [${storageFailure}]` : ""}`,
+  );
+  error.code = "CC_EXECUTION_LOCATION_TARGET_COMMAND_FAILED";
+  error.failureCategory = failureCategory;
+  if (failureSite) error.failureSite = failureSite;
+  if (storageFailure) error.storageFailure = storageFailure;
+  return error;
+}
+
 function runTargetCommand(profile, cliArgs, deps = {}, options = {}) {
   const invocation = targetInvocation(profile, cliArgs, deps, options);
   const spawnSync =
@@ -976,9 +1057,14 @@ function runTargetCommand(profile, cliArgs, deps = {}, options = {}) {
     ) {
       throw new Error("target command output boundary is invalid");
     }
-    const timeoutMs = Number(
-      options.timeoutMs ?? DEFAULT_TARGET_COMMAND_TIMEOUT_MS,
-    );
+    // Hosted Windows Local targets can spend most of the generic 30-second
+    // window on owner-only ACL checks before the CLI command runs. Keep the
+    // existing bounded 120-second ceiling for this attested target platform.
+    const defaultTimeoutMs =
+      profile.target === "local" && profile.expected.platform === "win32"
+        ? MAX_TARGET_COMMAND_TIMEOUT_MS
+        : DEFAULT_TARGET_COMMAND_TIMEOUT_MS;
+    const timeoutMs = Number(options.timeoutMs ?? defaultTimeoutMs);
     if (
       !Number.isSafeInteger(timeoutMs) ||
       timeoutMs < 1 ||
@@ -1008,12 +1094,20 @@ function runTargetCommand(profile, cliArgs, deps = {}, options = {}) {
           ],
       ...(invocation.spawnOptions || {}),
     });
-    if (result?.error) throw result.error;
+    if (result?.error) throw targetProcessFailure(result);
     if (!result || result.status !== 0) {
+      const failureCategory = targetCommandFailureCategory(result);
+      const failureSite = readExecutionLocationFailureSite(result?.stderr);
+      const storageFailure = readExecutionLocationStorageFailure(
+        result?.stderr,
+      );
       const error = new Error(
-        `target command failed with status ${result?.status ?? "unknown"}`,
+        `target command failed with status ${result?.status ?? "unknown"} (${failureCategory})${failureSite ? ` at ${failureSite}` : ""}${storageFailure ? ` [${storageFailure}]` : ""}`,
       );
       error.code = "CC_EXECUTION_LOCATION_TARGET_COMMAND_FAILED";
+      error.failureCategory = failureCategory;
+      if (failureSite) error.failureSite = failureSite;
+      if (storageFailure) error.storageFailure = storageFailure;
       throw error;
     }
     return options.interactive ? null : result.stdout;
@@ -1187,7 +1281,7 @@ export function probeExecutionLocationTargetResourceLimit(
   } finally {
     invocation.cleanup?.();
   }
-  if (result?.error) throw result.error;
+  if (result?.error) throw targetProcessFailure(result);
   const expectedMarker = `CC_EXECUTION_LOCATION_RESOURCE_PROBE_ARMED:${kind}`;
   const status = Number(result?.status);
   const signal = result?.signal == null ? null : String(result.signal);

package/src/lib/external-agent-adapters.js

@@ -15,6 +15,8 @@ export const EXTERNAL_AGENT_ERROR = Object.freeze({
   TIMEOUT: "EXTERNAL_AGENT_TIMEOUT",
   EXIT_NONZERO: "EXTERNAL_AGENT_EXIT_NONZERO",
   SPAWN_FAILED: "EXTERNAL_AGENT_SPAWN_FAILED",
+  CLEANUP_UNCONFIRMED: "EXTERNAL_AGENT_CLEANUP_UNCONFIRMED",
+  EXECUTION_BLOCKED: "EXTERNAL_AGENT_EXECUTION_BLOCKED",
   PROTOCOL_FAILED: "EXTERNAL_AGENT_PROTOCOL_FAILED",
   UNSUPPORTED_OPTION: "EXTERNAL_AGENT_UNSUPPORTED_OPTION",
 });