onto-mcp 0.4.12 → 0.4.13

package/dist/core-runtime/cli/run-seats.js

@@ -0,0 +1,18 @@
+/**
+ * `onto seats` — print a read-only inventory of every LLM model seat the
+ * runtime can dispatch, resolved against the settings.json chain for the
+ * current project. Discovery only: it writes nothing and changes no behaviour.
+ */
+import { resolveSettingsChain } from "../discovery/settings-chain.js";
+import { collectSeatInventory, renderSeatInventoryTable, } from "../discovery/seat-inventory.js";
+export async function runSeats(argv) {
+    const asJson = argv.includes("--json");
+    const settings = await resolveSettingsChain(process.cwd(), process.cwd());
+    const rows = collectSeatInventory(settings);
+    if (asJson) {
+        console.log(JSON.stringify(rows, null, 2));
+        return 0;
+    }
+    console.log(renderSeatInventoryTable(rows));
+    return 0;
+}

package/dist/core-runtime/cli/runtime-submit-context.js

@@ -129,8 +129,11 @@ export function parseRuntimeIssueStanceSchemaContext(rawPacketText) {
         const lensId = requireStringValue(finding.lens_id, `Runtime Issue Stance Input Projection.finding_summaries[${index}].lens_id`);
         if (lensId !== requestedLensId)
             continue;
-        const findingId = requireStringValue(finding.finding_id, `Runtime Issue Stance Input Projection.finding_summaries[${index}].finding_id`);
-        addPromptRefVariants({ refs: requestedLensFindingRefs, artifactRef: findingLedgerRef, anchor: findingId });
+        // Issue-strict parity with the on-disk validator (issue-artifact-runtime
+        // buildStanceEvidenceRefs): the lens's RAW finding evidence refs are a
+        // per-lens union, but finding-ledger#findingId anchors are registered ONLY
+        // per issue (surface_finding_ids loop below) — a cross-issue anchor that
+        // passed submit here used to be rejected at the on-disk re-validation.
         for (const evidenceRef of stringArray(finding.evidence_refs, `Runtime Issue Stance Input Projection.finding_summaries[${index}].evidence_refs`)) {
             requestedLensFindingRefs.add(evidenceRef);
         }
@@ -173,6 +176,10 @@ export function parseRuntimeIssueStanceSchemaContext(rawPacketText) {
         for (const findingId of stringArray(issue.surface_finding_ids, `Runtime Issue Stance Input Projection.issues[${index}].surface_finding_ids`)) {
             addPromptRefVariants({ refs, artifactRef: findingLedgerRef, anchor: findingId });
             for (const relationId of relationRefsByFindingId.get(findingId) ?? []) {
+                // Bare relation id parity with the on-disk validator, which registers
+                // the raw id for graph-endpoint relations — a bare `rel-N` submit used
+                // to be rejected here but accepted on disk (live-observed class).
+                refs.add(relationId);
                 addPromptRefVariants({
                     refs,
                     artifactRef: relationGraphRef,
@@ -189,6 +196,7 @@ export function parseRuntimeIssueStanceSchemaContext(rawPacketText) {
             });
         }
         for (const relationId of dependencyRelationRefsByIssueId.get(issueId) ?? []) {
+            refs.add(relationId); // bare-id parity with the on-disk dependency loop
             addPromptRefVariants({
                 refs,
                 artifactRef: relationGraphRef,

package/dist/core-runtime/cli/unit-resubmit.js

@@ -0,0 +1,269 @@
+/**
+ * Bounded unit resubmit — pure decision/projection logic (no I/O, no LLM
+ * calls). Unit-agnostic: the error-spec construction and packet projection are
+ * shared across review units; per-unit failure classifiers select which
+ * validation rejections are correctable.
+ *
+ * When `review.execution.retry.resubmit.enabled` is on, a unit whose structured
+ * submit was rejected by a deterministic evidence-ref whitelist is re-requested
+ * through the unit's existing retry budget with an error spec injected into its
+ * prompt packet, instead of retrying blind.
+ *
+ * Wired units (§4-6a, §4-2c/2-A):
+ * - issue-stance: `issue_evidence_refs` whitelist. Exhaustion demotes the unit
+ *   to complete-with-failure (degradation-summary, disclosed non-blockingly)
+ *   rather than halting — unless the same validation class fails a strict
+ *   majority of stance units (structural defect → whole-run halt with
+ *   `halt_reason = correlated_validation: …`). The demotion/correlated
+ *   machinery is stance-only and reads the terminal outcome; the rare-poison
+ *   stance gate therefore retries only correctable validation failures and does
+ *   not reinterpret a later infra terminal failure as validation.
+ * - deliberation-response: `allowed_evidence_refs` whitelist. Exhaustion reuses
+ *   deliberation's existing non-halting degrade (unavailable-completion), so it
+ *   needs no demotion/correlated machinery. Only the submit-time rejection is
+ *   correctable; on-disk rejections run post-pool and degrade.
+ * - synthesis-response: `allowed_source_refs` whitelist (§4-2c/2-A). Its
+ *   rejection message always carries `source_refs_used` → substring-classified
+ *   output_contract, so its in-loop resubmit depends on the structural retry
+ *   gate. Exhaustion reuses synthesis's existing non-halting degrade
+ *   (completeUnavailableSynthesisResponseUnit); no demotion/correlated
+ *   machinery.
+ *
+ * This module owns the deterministic parts: failure classification, error
+ * spec construction, idempotent packet projection, and the correlated
+ * escalation decision. File I/O and dispatch stay in
+ * run-review-prompt-execution.
+ *
+ * Design: development-records/design/20260704-review-unit-resubmit-and-limit-breaker-design.md (설계 A),
+ *   development-records/design/20260707-s4-6a-deliberation-resubmit-design.md (§4-6a 확대).
+ */
+/** Marker delimiting the runtime-owned error spec section inside a packet.
+ * Replacement is idempotent: a later resubmit replaces the section instead of
+ * stacking a second copy. */
+export const RESUBMIT_ERROR_SPEC_BEGIN = "<!-- onto:resubmit-error-spec:begin -->";
+export const RESUBMIT_ERROR_SPEC_END = "<!-- onto:resubmit-error-spec:end -->";
+/** halt_reason prefix for the correlated-failure whole-run halt (F-A2). */
+export const CORRELATED_VALIDATION_HALT_REASON = "correlated_validation";
+/** Submit-time validator throw site
+ * (structured-output-tools `normalizeIssueStanceResponseSubmitArgs`). */
+const SUBMIT_UNSUPPORTED_REF_PATTERN = /submit_issue_stance_response\.stances\[(\d+)\]\.evidence_refs contains unsupported ref for (\S+): (.*)$/m;
+/** On-disk per-lens validator throw site
+ * (issue-artifact-runtime `validateIssueStanceResponseObject`). */
+const ON_DISK_UNSUPPORTED_REF_PATTERN = /issue-stance response for issue (\S+) and lens \S+ references unsupported evidence: (.*)$/m;
+/**
+ * Classify a unit failure message as an issue-stance unsupported-evidence-ref
+ * validation rejection. Anchors on BOTH runtime-owned throw sites: the
+ * submit-time whitelist (per-issue union set) and the stricter on-disk
+ * per-lens re-validation — either rejection is the same failure class for
+ * promotion purposes. Message text is not guaranteed to survive the worker
+ * adapters' stderr (see readFrozenUnsupportedRefViolation for the structural
+ * freeze-file source); this classifier is the in-process/message half.
+ * Returns null for every other failure class so infra failures (timeout,
+ * transport, empty output) keep their current semantics.
+ */
+export function classifyUnsupportedEvidenceRefFailure(message) {
+    const submitMatch = SUBMIT_UNSUPPORTED_REF_PATTERN.exec(message);
+    if (submitMatch) {
+        const stanceIndex = Number.parseInt(submitMatch[1], 10);
+        const issueId = submitMatch[2];
+        const evidenceRef = submitMatch[3].trim();
+        if (!Number.isFinite(stanceIndex) || issueId.length === 0)
+            return null;
+        return { stanceIndex, issueId, evidenceRef };
+    }
+    const onDiskMatch = ON_DISK_UNSUPPORTED_REF_PATTERN.exec(message);
+    if (onDiskMatch) {
+        const issueId = onDiskMatch[1];
+        const evidenceRef = onDiskMatch[2].trim();
+        if (issueId.length === 0)
+            return null;
+        return { stanceIndex: null, issueId, evidenceRef };
+    }
+    return null;
+}
+export function isUnsupportedEvidenceRefFailureMessage(message) {
+    return (typeof message === "string" &&
+        classifyUnsupportedEvidenceRefFailure(message) !== null);
+}
+/** Submit-time throw site (structured-output-tools `assertAllowedRefs` via
+ * `normalizeIssueDeliberationResponseSubmitArgs`). This is the only deliberation
+ * evidence_refs rejection reachable by resubmit: the executor throws it during
+ * the dispatch (retryable) and freezes it as the salvage input. The on-disk
+ * validator (`validateIssueDeliberationResponseObject`) runs post-pool and is
+ * caught into a non-halting degrade — it never re-enters the retry loop — so it
+ * is deliberately not anchored here. */
+const SUBMIT_DELIBERATION_UNSUPPORTED_REF_PATTERN = /submit_issue_deliberation_response\.evidence_refs contains unsupported ref: (.*)$/m;
+/**
+ * Classify a unit failure message as a submit-time deliberation-response
+ * unsupported-evidence-ref rejection. Returns null for every other class so
+ * infra failures — and on-disk rejections, which degrade rather than resubmit —
+ * keep their current semantics.
+ */
+export function classifyDeliberationUnsupportedEvidenceRefFailure(message) {
+    const submitMatch = SUBMIT_DELIBERATION_UNSUPPORTED_REF_PATTERN.exec(message);
+    if (submitMatch) {
+        const evidenceRef = submitMatch[1].trim();
+        if (evidenceRef.length === 0)
+            return null;
+        return { evidenceRef };
+    }
+    return null;
+}
+/** Submit-time throw sites in `normalizeIssueSynthesisResponseSubmitArgs`
+ * (structured-output-tools): `assertAllowedRefs` for a bad ref, and the
+ * "must include at least one" guard for an all-invalid set. The empty
+ * allowed-set rejection ("cannot validate … because allowed_source_refs is
+ * empty") is deliberately NOT matched — an empty allowed set is a runtime/context
+ * condition a resubmit cannot correct, so it stays non-retryable. */
+const SUBMIT_SYNTHESIS_UNSUPPORTED_REF_PATTERN = /submit_issue_synthesis_response\.source_refs_used contains unsupported ref: (.*)$/m;
+const SUBMIT_SYNTHESIS_MISSING_ALLOWED_REF_PATTERN = /submit_issue_synthesis_response\.source_refs_used must include at least one allowed source ref\./;
+/**
+ * Classify a unit failure message as a submit-time synthesis-response
+ * unsupported/missing source-ref rejection. Returns null for every other class
+ * (including the non-correctable empty-allowed-set rejection) so infra failures
+ * keep their current semantics.
+ */
+export function classifySynthesisUnsupportedSourceRefFailure(message) {
+    const unsupported = SUBMIT_SYNTHESIS_UNSUPPORTED_REF_PATTERN.exec(message);
+    if (unsupported) {
+        const sourceRef = unsupported[1].trim();
+        if (sourceRef.length === 0)
+            return null;
+        return { sourceRef };
+    }
+    if (SUBMIT_SYNTHESIS_MISSING_ALLOWED_REF_PATTERN.test(message)) {
+        return { sourceRef: null };
+    }
+    return null;
+}
+/**
+ * Neutralize the runtime-owned section markers inside a value before it is
+ * interpolated into the spec. The rejected `evidence_ref` is model-controlled;
+ * a value literally containing an END (or BEGIN) marker would land as a
+ * premature delimiter inside the spec and fool the idempotent strip
+ * (`indexOf(END, begin)` matches the injected marker first), orphaning spec
+ * fragments and breaking the at-most-one-spec invariant across resubmit rounds.
+ * Marker-free values (every normal ref) are returned unchanged, so this is a
+ * no-op for the common path. Applied to every dynamic interpolation for
+ * defense-in-depth even though only the ref is model-controlled today.
+ */
+function neutralizeSpecMarkers(value) {
+    return value
+        .split(RESUBMIT_ERROR_SPEC_BEGIN)
+        .join("(spec marker removed)")
+        .split(RESUBMIT_ERROR_SPEC_END)
+        .join("(spec marker removed)");
+}
+/**
+ * Render the bounded error spec for a resubmit attempt. Contains only the
+ * violation and the allowed set for the offending unit — never the failed
+ * output itself (design: no full-output retransmission; the model rebuilds
+ * the complete payload from the unchanged packet body). Unit-agnostic: the
+ * `unit` descriptor selects the submit tool, rejected-unit label, allowed-set
+ * header, and closing instruction; stance is the default and unchanged.
+ */
+export function buildResubmitErrorSpec(args) {
+    const { violation } = args;
+    const evidenceRef = neutralizeSpecMarkers(violation.evidenceRef);
+    const issueId = neutralizeSpecMarkers(violation.issueId);
+    // Field-name vocabulary differs by unit: stance/deliberation reject
+    // `evidence_refs`, synthesis rejects `source_refs_used`. Defaulting to the
+    // evidence_refs vocabulary keeps stance/deliberation output byte-identical.
+    const refFieldPlural = args.unit?.kind === "synthesis" ? "source_refs_used" : "evidence_refs";
+    const refFieldSingular = args.unit?.kind === "synthesis" ? "source ref" : "evidence_ref";
+    const allowedBlock = args.allowedEvidenceRefs.length > 0
+        ? args.allowedEvidenceRefs
+            .map((ref) => `- ${neutralizeSpecMarkers(ref)}`)
+            .join("\n")
+        : `- (none — omit ${refFieldPlural} entries you cannot support)`;
+    const spec = args.unit?.kind === "deliberation"
+        ? {
+            submitTool: "submit_issue_deliberation_response",
+            rejectedLine: `- rejected: deliberation for issue_id: ${issueId}, lens_id: ${neutralizeSpecMarkers(args.unit.lensId)}`,
+            allowedHeader: "- allowed evidence_refs:",
+            closing: [
+                "Every evidence_ref must come from the allowed set in the schema",
+                "context above. Resubmit the full deliberation response, not only the",
+                "rejected entry.",
+            ],
+        }
+        : args.unit?.kind === "synthesis"
+            ? {
+                submitTool: "submit_issue_synthesis_response",
+                rejectedLine: `- rejected: synthesis response for issue_id: ${issueId}`,
+                allowedHeader: "- allowed source_refs_used:",
+                closing: [
+                    "Every source ref must come from the allowed set in the schema",
+                    "context above. Resubmit the full synthesis response, not only the",
+                    "rejected entry.",
+                ],
+            }
+            : {
+                submitTool: "submit_issue_stance_response",
+                rejectedLine: `- rejected stance: ${violation.stanceIndex !== null
+                    ? `stances[${violation.stanceIndex}] (issue_id: ${issueId})`
+                    : `stance for issue_id: ${issueId}`}`,
+                allowedHeader: `- allowed evidence_refs for ${issueId}:`,
+                closing: [
+                    "Every stance's evidence_refs must come from that issue's allowed set in",
+                    "the schema context above. Resubmit the full stances array, not only the",
+                    "rejected entry.",
+                ],
+            };
+    // A specific offending ref → name it; an empty ref (synthesis "must include at
+    // least one" rejection) → instruct citing from the allowed set instead.
+    const refLine = evidenceRef.length > 0
+        ? `- unsupported ${refFieldSingular}: ${evidenceRef}`
+        : `- you cited no allowed ${refFieldSingular}; include at least one from the allowed set below`;
+    return [
+        RESUBMIT_ERROR_SPEC_BEGIN,
+        "",
+        `## Resubmit required: ${refFieldPlural} validation rejected (attempt ${args.resubmitAttempt})`,
+        "",
+        `Your previous ${spec.submitTool} call was rejected by`,
+        "deterministic validation. Do not apologize or explain; call the submit",
+        "tool again with a complete corrected payload.",
+        "",
+        spec.rejectedLine,
+        refLine,
+        spec.allowedHeader,
+        allowedBlock,
+        "",
+        ...spec.closing,
+        "",
+        RESUBMIT_ERROR_SPEC_END,
+    ].join("\n");
+}
+/**
+ * Project the error spec into a packet idempotently: strips a previous
+ * runtime-owned spec section (if any) before appending the new one, so the
+ * packet carries at most one spec regardless of how many resubmit rounds ran.
+ */
+export function applyResubmitErrorSpecToPacket(packetText, errorSpec) {
+    const stripped = stripResubmitErrorSpec(packetText);
+    return `${stripped.trimEnd()}\n\n${errorSpec.trimEnd()}\n`;
+}
+function stripResubmitErrorSpec(packetText) {
+    const begin = packetText.indexOf(RESUBMIT_ERROR_SPEC_BEGIN);
+    if (begin === -1)
+        return packetText;
+    const end = packetText.indexOf(RESUBMIT_ERROR_SPEC_END, begin);
+    if (end === -1)
+        return packetText.slice(0, begin);
+    return (packetText.slice(0, begin) +
+        packetText.slice(end + RESUBMIT_ERROR_SPEC_END.length));
+}
+export function packetHasResubmitErrorSpec(packetText) {
+    return packetText.includes(RESUBMIT_ERROR_SPEC_BEGIN);
+}
+/**
+ * Correlated escalation decision: the same validation class failing a strict
+ * majority (>50%) of stance units signals a structural defect (prompt,
+ * schema, or context assembly), not per-unit output noise — whole-run halt
+ * stays the correct promotion there.
+ */
+export function correlatedValidationExceeded(args) {
+    if (args.totalUnitCount <= 0)
+        return false;
+    return args.validationFailedUnitCount * 2 > args.totalUnitCount;
+}

package/dist/core-runtime/cli/worker-structured-output.js

@@ -115,8 +115,9 @@ function requireRecord(value, label) {
 }
 /**
  * Normalize a JSON Schema into the strict shape external workers require: every
- * object's properties become `required`. Mirrors what the Codex `--output-schema`
- * and Claude `--json-schema` flags expect for structured output.
+ * object's properties become `required`, and homogeneous `anyOf` object rows are
+ * collapsed to a single provider-compatible object. Runtime submit validation
+ * remains the authority for issue-specific allowed sets.
  */
 export function toWorkerStructuredOutputSchema(schema) {
     if (Array.isArray(schema)) {
@@ -129,12 +130,89 @@ export function toWorkerStructuredOutputSchema(schema) {
     for (const [key, value] of Object.entries(schema)) {
         normalized[key] = toWorkerStructuredOutputSchema(value);
     }
+    const collapsedAnyOf = collapseHomogeneousAnyOf(normalized);
+    if (collapsedAnyOf)
+        return collapsedAnyOf;
     const properties = normalized.properties;
     if (properties && typeof properties === "object" && !Array.isArray(properties)) {
         normalized.required = Object.keys(properties);
     }
     return normalized;
 }
+function collapseHomogeneousAnyOf(schema) {
+    const variants = schema.anyOf;
+    if (!Array.isArray(variants) || variants.length === 0)
+        return null;
+    const records = variants.filter((variant) => !!variant && typeof variant === "object" && !Array.isArray(variant));
+    if (records.length !== variants.length)
+        return null;
+    if (!records.every((record) => record.type === "object"))
+        return null;
+    const propertySets = records.map((record) => record.properties &&
+        typeof record.properties === "object" &&
+        !Array.isArray(record.properties)
+        ? Object.keys(record.properties).sort()
+        : null);
+    const firstSet = propertySets[0];
+    if (!firstSet)
+        return null;
+    if (!propertySets.every((set) => !!set &&
+        set.length === firstSet.length &&
+        set.every((key, index) => key === firstSet[index]))) {
+        return null;
+    }
+    const mergedProperties = {};
+    for (const key of firstSet) {
+        const merged = mergeHomogeneousProperty(records.map((record) => record.properties[key]));
+        if (merged === null)
+            return null;
+        mergedProperties[key] = merged;
+    }
+    const collapsed = {
+        type: "object",
+        additionalProperties: records.every((record) => record.additionalProperties === false)
+            ? false
+            : schema.additionalProperties,
+        properties: mergedProperties,
+        required: Object.keys(mergedProperties),
+    };
+    if (typeof schema.description === "string") {
+        collapsed.description = schema.description;
+    }
+    return collapsed;
+}
+function mergeHomogeneousProperty(values) {
+    const records = values.filter((value) => !!value && typeof value === "object" && !Array.isArray(value));
+    if (records.length !== values.length)
+        return sameJson(values) ? values[0] : null;
+    const first = records[0];
+    if (!first)
+        return null;
+    const comparable = records.map(({ enum: _enum, description: _description, ...rest }) => rest);
+    if (sameJson(comparable)) {
+        const enumValues = records.flatMap((record) => Array.isArray(record.enum) ? record.enum : []);
+        const base = {
+            ...comparable[0],
+            ...(typeof first.description === "string"
+                ? { description: first.description }
+                : {}),
+        };
+        if (enumValues.length > 0) {
+            return {
+                ...base,
+                enum: Array.from(new Set(enumValues.map((value) => JSON.stringify(value)))).map((value) => JSON.parse(value)),
+            };
+        }
+        return base;
+    }
+    return sameJson(records) ? first : null;
+}
+function sameJson(values) {
+    if (values.length === 0)
+        return true;
+    const first = JSON.stringify(values[0]);
+    return values.every((value) => JSON.stringify(value) === first);
+}
 /**
  * Build the submit-tool JSON Schema and the submission state for an output
  * format, without writing any file. Codex writes this to disk for its

package/dist/core-runtime/discovery/host-detection.js

@@ -1,6 +1,8 @@
+import { execFileSync } from "node:child_process";
 import fsSync from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { resolveClaudeBin } from "../llm/claude-bin.js";
 const CODEX_ENV_SIGNALS = ["CODEX_THREAD_ID", "CODEX_CI"];
 /** True when the current process is running under a Codex-owned session. */
 export function detectCodexEnvSignal() {
@@ -31,40 +33,87 @@ export function detectCodexBinaryAvailable() {
         return false;
     return fsSync.existsSync(path.join(os.homedir(), ".codex", "auth.json"));
 }
-/** OAuth credential filenames Claude Code may write under its config dir. */
+/** OAuth credential filenames older Claude Code builds write under its config
+ * dir. Newer builds store the credential in the OS keychain (macOS) instead, so
+ * this file probe is the backward-compatible fallback, not the primary check. */
 const CLAUDE_OAUTH_CREDENTIAL_FILENAMES = [
     ".credentials.json",
     ".oauth-token",
 ];
-function claudeConfigDir() {
-    const configured = process.env.CLAUDE_CONFIG_DIR;
+/** Bound on the `claude auth status` probe so a wedged CLI cannot hang review
+ * profile resolution. The command is a local credential read (~200ms observed),
+ * so this is a generous ceiling, not a normal latency. */
+const CLAUDE_AUTH_STATUS_TIMEOUT_MS = 5000;
+function claudeConfigDir(env) {
+    const configured = env.CLAUDE_CONFIG_DIR;
     if (typeof configured === "string" && configured.trim().length > 0) {
         return configured.trim();
     }
     return path.join(os.homedir(), ".claude");
 }
-/**
- * True when the Claude Code worker path can be used from this process.
- *
- * Mirrors {@link detectCodexBinaryAvailable}: both the executable and an OAuth
- * credential are required so the external OAuth worker (`claude_code` adapter)
- * route stays fail-loud when the host-bound worker is unavailable. The config
- * dir honors CLAUDE_CONFIG_DIR; the credential filename is tolerant of the
- * known Claude Code variants.
- */
-export function detectClaudeBinaryAvailable() {
-    const pathEnv = process.env.PATH ?? "";
-    let claudeOnPath = false;
+function claudeBinaryOnPath(env) {
+    const pathEnv = env.PATH ?? "";
     for (const dir of pathEnv.split(path.delimiter)) {
         if (!dir)
             continue;
-        if (fsSync.existsSync(path.join(dir, "claude"))) {
-            claudeOnPath = true;
-            break;
-        }
+        if (fsSync.existsSync(path.join(dir, "claude")))
+            return true;
     }
-    if (!claudeOnPath)
-        return false;
-    const configDir = claudeConfigDir();
+    return false;
+}
+function hasClaudeCredentialFile(env) {
+    const configDir = claudeConfigDir(env);
     return CLAUDE_OAUTH_CREDENTIAL_FILENAMES.some((name) => fsSync.existsSync(path.join(configDir, name)));
 }
+/**
+ * Parse the JSON `claude auth status` prints. Returns its `loggedIn` boolean
+ * when the output is the recognized shape, or null otherwise (older CLI without
+ * the command, an error, or a format change) so the caller can fall back to the
+ * file-credential probe. Pure — unit-testable without spawning the CLI.
+ */
+export function parseClaudeAuthLoggedIn(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        return typeof parsed?.loggedIn === "boolean" ? parsed.loggedIn : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * True when the Claude Code worker path can be used from this process.
+ *
+ * The authority on whether the worker can authenticate is the claude CLI
+ * itself: `claude auth status` reports login across every credential store
+ * (macOS Keychain, credential file, or env token) and every OS — which a
+ * file-only probe cannot (a keychain-backed login leaves no credential file).
+ * The worker spawns the same CLI, so this checks the exact auth path the run
+ * will use. Binary resolution mirrors the executor via {@link resolveClaudeBin}
+ * (ONTO_CLAUDE_BIN override + PATH).
+ *
+ * Falls back to the legacy file-credential probe when the CLI cannot answer
+ * (missing binary, timeout, or a build too old for `auth status`), so setups
+ * that resolved before this change keep resolving (backward compatible). Unlike
+ * {@link detectCodexBinaryAvailable}, which reads codex's on-disk
+ * `~/.codex/auth.json` directly, claude's credential is not reliably a file —
+ * hence the CLI delegation.
+ */
+export function detectClaudeBinaryAvailable(env = process.env) {
+    const claudeBin = resolveClaudeBin(env);
+    try {
+        const stdout = execFileSync(claudeBin, ["auth", "status"], {
+            env,
+            timeout: CLAUDE_AUTH_STATUS_TIMEOUT_MS,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const loggedIn = parseClaudeAuthLoggedIn(stdout);
+        if (loggedIn !== null)
+            return loggedIn;
+    }
+    catch {
+        // ENOENT (no binary), timeout, non-zero exit, or a CLI too old to support
+        // `auth status` — fall through to the legacy file-credential probe.
+    }
+    return claudeBinaryOnPath(env) && hasClaudeCredentialFile(env);
+}