mtech-ai-local-runner 0.1.60 → 0.1.62

package/README.md

@@ -889,10 +889,12 @@ The reviewed manual Codex path preserves the existing CLI and ChatGPT login. It
 ### Local Fix with disclosed validation
 
 The existing daemon can use a reviewed `gateway_publish_v1` installation for
-approved local Codex fixes. It freezes the owned model and sends only sealed,
-bounded changed text files to Gateway's existing publication service. Server
-credentials create the generated branch and canonical development PR; no local
-Git token, ECR, new CI installation or native PHP verifier is required.
+approved local Codex fixes, and Claude fixes once the Gateway lists a reviewed
+Claude release and the runner reports Claude ready. It freezes the owned model
+and sends only sealed, bounded changed text files to Gateway's existing
+publication service. Server credentials create the generated branch and
+canonical development PR; no local Git token, ECR, new CI installation or native
+PHP verifier is required.
 
 Validation is explicitly **UNVERIFIED** in this mode, with CI **not run**.
 Executor-reported checks, failures and checks not run stay attributed to the
@@ -915,6 +917,10 @@ the older `authenticated` field still means execution eligibility. A logged-in
 Claude account can remain blocked by unverified security admission. Do not log out
 or change credentials just because that legacy field is false. Unknown status is
 not evidence of logout. These diagnostics do not bypass per-job admission.
+Claude reports `CLAUDE_RELEASE_NOT_LISTED` while the Gateway lists no reviewed
+Claude release. Claude readiness may lag a Claude login or logout by up to 5
+minutes, because the runner asks the pinned copy for the login state at most that
+often.
 
 ### 0.1.50: small edits and publication-only Fix
 

package/dist/src/adapters/claude-code/adapter.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { requireSecurityRequirements } from '../../safety/security-requirements.js';
+import { CLAUDE_RELEASE_MODE, CLAUDE_TRANSPORT } from '../../safety/claude-release.js';
 import { createJobSecurityReceipt } from '../../safety/job-security-receipt.js';
 import { isTerminalEventType } from "../../protocol.js";
 import { parseClaudeLine } from "./stream-parser.js";
@@ -92,7 +93,11 @@ export class ClaudeCodeAdapter {
                 if (ctx.approvedTaskPackage?.resolved_provider !== "anthropic" || ctx.approvedTaskPackage?.resolved_model_id !== resolvedModelId
                     || ctx.approvedTaskPackage?.repository?.base_commit_sha !== this.options.securityPolicy.pin.sourceSha)
                     throw new Error("SECURITY_REQUIREMENTS_REJECTED");
-                requireSecurityRequirements(ctx.approvedTaskPackage?.security_requirements, { adapterId: "claude_code_cli", adapterVersion: "1", requirementsSha256: this.options.securityPolicy.pin.requirementsSha256 });
+                const requirements = requireSecurityRequirements(ctx.approvedTaskPackage?.security_requirements, { adapterId: "claude_code_cli", adapterVersion: "1", requirementsSha256: this.options.securityPolicy.pin.requirementsSha256 });
+                // Release mode (decision 9095c7a8): the approved package carries the fixed stream-json transport and a model of its release.
+                if (requirements.security_mode === CLAUDE_RELEASE_MODE && (ctx.approvedTaskPackage?.runtime_transport !== CLAUDE_TRANSPORT
+                    || !requirements.model_ids.includes(resolvedModelId)))
+                    throw new Error("SECURITY_REQUIREMENTS_REJECTED");
             };
             assertAdmission();
             if (!ctx.securityBinding)
@@ -277,6 +282,23 @@ export class ClaudeCodeAdapter {
         });
         return this.cancelPromise;
     }
+    /** Owned exit before credential-bearing publication, with Codex semantics (decision 9095c7a8). It revokes the job
+     * security session and the MCP endpoint, stops the owned process group and confirms it within 10 seconds. */
+    async freezeForPublication() {
+        if (!this.started || !this.handle?.terminateOwned)
+            throw new Error('CLAUDE_PUBLICATION_FREEZE_UNCONFIRMED');
+        let timer;
+        try {
+            await Promise.race([this.cancel(), new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('CLAUDE_PUBLICATION_FREEZE_UNCONFIRMED')), 10_000); })]);
+        }
+        catch {
+            throw new Error('CLAUDE_PUBLICATION_FREEZE_UNCONFIRMED');
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     securityRevoked = false;
     revokeSecurity() {
         if (this.securityRevoked)
@@ -369,6 +391,6 @@ export class ClaudeCodePlugin {
         return { ...result, capabilities: result.capabilities ?? this.capabilities };
     }
     async create(input) {
-        return new ClaudeCodeAdapter(this.pluginOptions.options(input));
+        return new ClaudeCodeAdapter(await this.pluginOptions.options(input));
     }
 }

package/dist/src/adapters/claude-code/login-status.js

@@ -0,0 +1,15 @@
+/** Reads `claude auth status --json` stdout without returning raw output. `loggedOutExit` marks Claude's exit 1,
+ * which never proves a login. Anything unparsable stays unknown. */
+export function claudeLoginFromStatus(stdout, loggedOutExit = false) {
+    try {
+        const value = JSON.parse(stdout);
+        if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.loggedIn === 'boolean') {
+            const loggedIn = value.loggedIn;
+            if (loggedOutExit && loggedIn)
+                return { authenticated: false, loginStatus: 'unknown' };
+            return { authenticated: loggedIn, loginStatus: loggedIn ? 'authenticated' : 'unauthenticated' };
+        }
+    }
+    catch { /* Unknown evidence stays closed; never expose raw output. */ }
+    return { authenticated: false, loginStatus: 'unknown' };
+}

package/dist/src/adapters/discovery.js

@@ -1,4 +1,5 @@
 import { adapterStatus } from './status.js';
+import { claudeLoginFromStatus } from './claude-code/login-status.js';
 import { createCodexProductionHost } from '../safety/codex-production-host.js';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -22,16 +23,6 @@ export async function discoverAdapters(env, command = run, adapterIds = ['claude
                 throw new Error('invalid version');
             let authenticated = false;
             let loginStatus = 'unknown';
-            const parseClaudeStatus = (stdout) => {
-                try {
-                    const value = JSON.parse(stdout);
-                    if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.loggedIn === 'boolean') {
-                        authenticated = value.loggedIn;
-                        loginStatus = authenticated ? 'authenticated' : 'unauthenticated';
-                    }
-                }
-                catch { /* Unknown evidence stays closed; never expose raw output. */ }
-            };
             try {
                 const auth = await command(binary, codex ? ['login', 'status'] : ['auth', 'status', '--json']);
                 if (codex) {
@@ -39,20 +30,15 @@ export async function discoverAdapters(env, command = run, adapterIds = ['claude
                     loginStatus = authenticated ? 'authenticated' : 'unauthenticated';
                 }
                 else
-                    parseClaudeStatus(auth.stdout);
+                    ({ authenticated, loginStatus } = claudeLoginFromStatus(auth.stdout));
             }
             catch (error) {
                 // Claude exits 1 for a known logged-out JSON response. Other failures
                 // (including timeout/permission errors) do not prove logout.
                 if (!codex && error && typeof error === 'object' && error.code === 1) {
                     const stdout = error.stdout;
-                    if (typeof stdout === 'string') {
-                        parseClaudeStatus(stdout);
-                        if (authenticated) {
-                            authenticated = false;
-                            loginStatus = 'unknown';
-                        }
-                    }
+                    if (typeof stdout === 'string')
+                        ({ authenticated, loginStatus } = claudeLoginFromStatus(stdout, true));
                 }
             }
             if (codex) {

package/dist/src/asks/inbox.js

@@ -1,5 +1,5 @@
 import { emptyAskState, pruneAskState, sessionKey } from "./store.js";
-import { addDeliveries, claimOpen, closeDeliveries, confirmNotified, confirmOpened, confirmWake, isLive, planRoutes, preferredApp, promptSubmitted, releaseOpen, sessionEnded, sessionStarted, turnEnded, } from "./routing.js";
+import { addDeliveries, claimOpen, closeDeliveries, confirmNotified, confirmOpened, confirmWake, isLive, openApp, planRoutes, promptSubmitted, releaseOpen, sessionEnded, sessionStarted, turnEnded, } from "./routing.js";
 import { droppableDeliveryId, parseAskDelivery } from "./types.js";
 import { renderOutput } from "./templates.js";
 import { PRESENCE_RECHECK_MS } from "./presence.js";
@@ -292,11 +292,16 @@ export class AskInbox {
         // Claimed before anything runs, so a delivery is never opened or notified twice.
         const opening = new Set(plan.open.map(item => item.deliveryId));
         claimOpen(this.state, [...opening], now);
-        for (const item of plan.notify)
+        for (const item of [...plan.notify, ...plan.held])
             confirmNotified(this.state, item.deliveryId, now, false);
         const notify = plan.notify.map(item => item.deliveryId);
+        const held = plan.held.flatMap(item => {
+            const session = item.sessionKey === null ? undefined : this.state.sessions[item.sessionKey];
+            return session === undefined ? [] : [{ deliveryId: item.deliveryId, app: session.app }];
+        });
         return {
             notify: notify.filter(id => !opening.has(id)),
+            held,
             // The notification of a delivery in the open waits for its outcome, which decides the text.
             open: opening.size === 0 ? null : { deliveryIds: [...opening], notifyAfter: notify.filter(id => opening.has(id)) },
         };
@@ -306,6 +311,8 @@ export class AskInbox {
         await this.persist();
         if (work.notify.length > 0)
             this.startNotifying(work.notify);
+        for (const { deliveryId, app } of work.held)
+            this.startNotifying([deliveryId], { heldIn: app });
         if (work.open !== null)
             this.startOpening(work.open);
         try {
@@ -411,7 +418,7 @@ export class AskInbox {
             return { status: "skipped" };
         const kinds = { asks: items.some(item => item.direction === "ask"), answers: items.some(item => item.direction === "answer") };
         try {
-            return await this.deps.openSession(preferredApp(this.state), kinds);
+            return await this.deps.openSession(openApp(this.state, items), kinds);
         }
         catch {
             return { status: "failed", code: "open_failed" };

package/dist/src/asks/notifier.js

@@ -25,6 +25,11 @@ const OPENED_TEXT = {
         codex: "AI Gateway: your ask has an answer. A Codex session is open to continue.",
     },
 };
+/** An answer held in its live asking session (Work Decision 8562d191): no session is opened, the person goes back to it. */
+const HELD_TEXT = {
+    claude: "AI Gateway: your ask has an answer. It is waiting in the Claude session that asked. Type there to see it.",
+    codex: "AI Gateway: your ask has an answer. It is waiting in the Codex session that asked. Type there to see it.",
+};
 export const OSASCRIPT = "/usr/bin/osascript";
 const SCRIPT = ["on run argv", "display notification (item 1 of argv) with title \"AI Gateway\"", "end run"];
 /**
@@ -34,6 +39,8 @@ const SCRIPT = ["on run argv", "display notification (item 1 of argv) with title
  */
 export const NOTIFY_TIMEOUT_MS = 3_000;
 export function notificationText(item, options = {}) {
+    if (options.heldIn !== undefined)
+        return HELD_TEXT[options.heldIn];
     if (options.openedApp !== undefined)
         return OPENED_TEXT[item.direction][options.openedApp];
     return (item.direction === "ask" ? ASK_TEXT : ANSWER_TEXT)[item.subjectType];

package/dist/src/asks/routing.js

@@ -59,13 +59,46 @@ export function preferredApp(state) {
     }
     return best?.app ?? null;
 }
+/**
+ * The live session on this Mac that made an answer's ask (Work Decision 8562d191): null for an ask, without a hash, or
+ * when that session is unknown here or no longer live.
+ */
+export function askerSessionKey(item, state, now) {
+    if (item.direction !== "answer" || item.askerSessionHash === undefined || item.askerSessionHash === null)
+        return null;
+    for (const [key, session] of Object.entries(state.sessions)) {
+        if (isLive(session, now) && hashSessionId(session.sessionId) === item.askerSessionHash)
+            return key;
+    }
+    return null;
+}
+/**
+ * The app an open uses: for answers only, the app of the first one whose asking session this Mac still knows, live or
+ * ended, so the new session opens where the person asked; otherwise preferredApp.
+ */
+export function openApp(state, items) {
+    if (items.length > 0 && items.every(item => item.direction === "answer")) {
+        for (const item of items) {
+            if (item.askerSessionHash === undefined || item.askerSessionHash === null)
+                continue;
+            const asking = Object.values(state.sessions).find(session => hashSessionId(session.sessionId) === item.askerSessionHash);
+            if (asking !== undefined)
+                return asking.app;
+        }
+    }
+    return preferredApp(state);
+}
 /**
  * Spec section 5: a live session the delivery names, else the live session with the most recent human prompt. A named
  * session counts only with a human prompt in the last 30 minutes: named sessions stay live until closed, and an older
  * one would otherwise keep the delivery from the session the person is using (2026-10-26 Test B). Among named sessions
- * the one listed first wins: the Gateway lists the session that made the ask first (2026-10-26 test C).
+ * the one listed first wins: the Gateway lists the session that made the ask first (2026-10-26 test C). An answer whose
+ * asking session is live goes there, however long ago it was typed in (Work Decision 8562d191).
  */
 export function chooseSession(item, state, now) {
+    const asking = askerSessionKey(item, state, now);
+    if (asking !== null)
+        return asking;
     const live = Object.entries(state.sessions).filter(([, session]) => isLive(session, now));
     const order = new Map(item.targetSessionHashes.map((hash, index) => [hash, index]));
     const rank = (session) => order.get(hashSessionId(session.sessionId)) ?? order.size;
@@ -84,17 +117,22 @@ export function chooseSession(item, state, now) {
  *   becomes the chosen one by that prompt (see promptSubmitted);
  * - an idle Claude session whose Stop watcher waits, under its hourly limit: woken now;
  * - otherwise (an idle Codex session, no watcher, or the limit reached): a notification.
+ * An answer whose asking session is live is pinned or woken there by the same rules, and otherwise held there: it waits
+ * for that session, with a notification that says so, and no session is opened for it (Work Decision 8562d191).
  */
 export function routeItem(item, state, now, watching) {
-    const key = chooseSession(item, state, now);
+    const asking = askerSessionKey(item, state, now);
+    const key = asking ?? chooseSession(item, state, now);
     const session = key === null ? undefined : state.sessions[key];
-    if (key === null || session === undefined || !humanPromptWithin(session, now))
+    if (key === null || session === undefined)
+        return { action: "notify" };
+    if (asking === null && !humanPromptWithin(session, now))
         return { action: "notify" };
     if (turnInProgress(session))
         return { action: "pin", sessionKey: key };
-    if (session.app === "claude" && watching.has(key) && wakesLeft(session, now) > 0)
+    if (session.app === "claude" && humanPromptWithin(session, now) && watching.has(key) && wakesLeft(session, now) > 0)
         return { action: "wake", sessionKey: key };
-    return { action: "notify" };
+    return asking === null ? { action: "notify" } : { action: "hold", sessionKey: key };
 }
 /** At most 5 spelled out, oldest first; the rest are summarized by one "and N more" line. */
 export function selectForOutput(items) {
@@ -263,6 +301,7 @@ export function sessionEnded(state, context) {
 export function planRoutes(state, now, watching, options = {}) {
     const wakeGroups = new Map();
     const notify = [];
+    const held = [];
     const unseen = [];
     for (const item of itemsWhere(state, item => item.phase === "waiting" || item.phase === "pinned")) {
         const decision = routeItem(item, state, now, watching);
@@ -276,12 +315,14 @@ export function planRoutes(state, now, watching, options = {}) {
         }
         item.phase = "pinned";
         item.sessionKey = decision.sessionKey;
+        if (decision.action === "hold" && item.notifiedAt === null)
+            held.push(item);
         if (decision.action === "wake")
             wakeGroups.set(decision.sessionKey, [...wakeGroups.get(decision.sessionKey) ?? [], item]);
     }
     const openable = unseen.filter(item => item.openedAt === null);
     const open = options.canOpen === true && openable.length > 0 && !openPending(state, now) && opensLeft(state, now) > 0 ? openable : [];
-    return { wakes: [...wakeGroups].map(([key, items]) => ({ sessionKey: key, output: selectForOutput(items) })), notify, open };
+    return { wakes: [...wakeGroups].map(([key, items]) => ({ sessionKey: key, output: selectForOutput(items) })), notify, held, open };
 }
 /** The hub delivered a wake to the session's watcher: everything in it counts as shown there. */
 export function confirmWake(state, key, output, now) {

package/dist/src/asks/runtime.js

@@ -6,6 +6,7 @@ import { installedApps } from "./integrations.js";
 import { createNotifier } from "./notifier.js";
 import { createPresenceReader } from "./presence.js";
 import { createSessionOpener } from "./opener.js";
+import { ASK_INBOX_VERSION } from "./types.js";
 /*
  * AI-first ask delivery inside the daemon (Work Item e1c08b33). It rides on the existing session-open loop:
  * no new long-poll. The hub runs for as long as that loop runs, deliveries from each wait are stored and
@@ -152,7 +153,7 @@ export class AskRuntime {
         catch {
             apps = [];
         }
-        return apps.length > 0 ? { version: 1, apps: [...apps] } : undefined;
+        return apps.length > 0 ? { version: ASK_INBOX_VERSION, apps: [...apps] } : undefined;
     }
     /** Resolves when the start settles or the bound passes, whichever comes first. Never rejects: start() never throws. */
     async waitForStart(starting) {

package/dist/src/asks/store.js

@@ -79,6 +79,10 @@ function normalizeItem(key, value) {
     // Missing in a file written before opens existed: never opened.
     if (v.openedAt !== undefined && !isTimeOrNull(v.openedAt))
         return null;
+    // Missing in a file written before 0.1.61 or from a seven-key delivery: no asking session known.
+    if (v.askerSessionHash !== undefined && v.askerSessionHash !== null
+        && (typeof v.askerSessionHash !== "string" || !SESSION_HASH.test(v.askerSessionHash)))
+        return null;
     const outbox = v.outbox.map(normalizeReport);
     if (outbox.some(report => report === null))
         return null;
@@ -86,7 +90,8 @@ function normalizeItem(key, value) {
         targetSessionHashes: [...v.targetSessionHashes], createdAt: v.createdAt, receivedAt: v.receivedAt,
         phase: settlePhase(v.phase, v.sessionKey),
         sessionKey: v.sessionKey, shownVia: v.shownVia, shownAt: v.shownAt, firstShownVia: v.firstShownVia,
-        notifiedAt: v.notifiedAt, openedAt: (v.openedAt ?? null), seenAt: v.seenAt, outbox: outbox };
+        notifiedAt: v.notifiedAt, openedAt: (v.openedAt ?? null), seenAt: v.seenAt, outbox: outbox,
+        ...(v.askerSessionHash === undefined ? {} : { askerSessionHash: v.askerSessionHash }) };
 }
 function normalizeSession(key, value) {
     if (value === null || typeof value !== "object")

package/dist/src/asks/types.js

@@ -9,6 +9,11 @@ export const SUBJECT_TYPES = ["decision", "review", "request"];
 export const DIRECTIONS = ["ask", "answer"];
 export const VIAS = ["prompt", "session_start", "stop", "rewake", "notification"];
 export const REPORT_EVENTS = ["received", "shown", "seen", "dropped"];
+/**
+ * heartbeat runner.session_open.ask_inbox: the integrations actually installed on this Mac. Version 2 says the runner
+ * reads asker_session_hash on deliveries (Work Decision 8562d191); it needs a Gateway that accepts version 2.
+ */
+export const ASK_INBOX_VERSION = 2;
 /** Gateway ids are lowercase UUIDs (contract: subject keys must be lowercase UUIDs). */
 export const LOWER_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 /** sha256 of a client session id, as the Gateway stores external_session_id_hash. */
@@ -22,8 +27,10 @@ export const OPEN_ASKS_LEAD = "AI Gateway: colleagues' AIs are waiting for you."
 export const OPEN_ANSWERS_LEAD = "AI Gateway: your asks have answers.";
 /** The most target session hashes one delivery may carry: a longer list is refused on the wire and dropped on load. */
 export const MAX_TARGET_HASHES = 50;
-// Sorted, so they compare directly with the sorted keys of a wire item.
+// Sorted, so they compare directly with the sorted keys of a wire item. A Gateway that knows this runner reads
+// ask_inbox version 2 adds asker_session_hash; an older one sends the seven keys only.
 const DELIVERY_FIELDS = ["created_at", "delivery_id", "direction", "subject_key", "subject_type", "target_session_hashes", "work_item_id"];
+const DELIVERY_FIELDS_WITH_ASKER = ["asker_session_hash", ...DELIVERY_FIELDS];
 function oneOf(values, value) {
     return typeof value === "string" && values.includes(value);
 }
@@ -39,9 +46,13 @@ export function parseAskDelivery(input) {
         return null;
     const record = input;
     const keys = Object.keys(record).sort();
-    if (keys.length !== DELIVERY_FIELDS.length || keys.some((key, index) => key !== DELIVERY_FIELDS[index]))
+    const withAsker = keys.includes("asker_session_hash");
+    const fields = withAsker ? DELIVERY_FIELDS_WITH_ASKER : DELIVERY_FIELDS;
+    if (keys.length !== fields.length || keys.some((key, index) => key !== fields[index]))
+        return null;
+    const { delivery_id: deliveryId, subject_type: subjectType, subject_key: subjectKey, direction, work_item_id: workItemId, target_session_hashes: hashes, created_at: createdAt, asker_session_hash: asker } = record;
+    if (withAsker && asker !== null && (typeof asker !== "string" || !SESSION_HASH.test(asker)))
         return null;
-    const { delivery_id: deliveryId, subject_type: subjectType, subject_key: subjectKey, direction, work_item_id: workItemId, target_session_hashes: hashes, created_at: createdAt } = record;
     if (typeof deliveryId !== "string" || !LOWER_UUID.test(deliveryId))
         return null;
     if (!isSubjectType(subjectType) || !isDirection(direction))
@@ -56,7 +67,8 @@ export function parseAskDelivery(input) {
         return null;
     if (typeof createdAt !== "number" || !Number.isSafeInteger(createdAt) || createdAt < 0)
         return null;
-    return { deliveryId, subjectType, subjectKey, direction, workItemId, targetSessionHashes: [...hashes], createdAt };
+    return { deliveryId, subjectType, subjectKey, direction, workItemId, targetSessionHashes: [...hashes], createdAt,
+        ...(withAsker ? { askerSessionHash: asker } : {}) };
 }
 /** The id of a wire item that failed validation, when the id itself is valid, so it can be reported as dropped. */
 export function droppableDeliveryId(input) {

package/dist/src/daemon/runtime.js

@@ -1,5 +1,7 @@
+import { createClaudeProductionHost } from '../safety/claude-production-host.js';
 import { adapterStatus } from '../adapters/status.js';
 import { loadInstalledLocalFixHost } from '../publication/installed-host.js';
+import { isLocalFixAdapter } from '../publication/local-fix-adapters.js';
 import { createCodexDaemonHost } from '../safety/codex-daemon-host.js';
 import { reconcileTerminalState } from './terminal-recovery.js';
 import { packageVersion } from '../package-version.js';
@@ -36,6 +38,15 @@ export async function buildDaemon(input) {
     const claudeParts = [input.claudeSecurityHost, input.claudeSupportedProbe, input.claudeBinaryIdentity].filter(Boolean).length;
     if (claudeParts !== 0 && claudeParts !== 3)
         throw new Error('CLAUDE_SUPPORTED_HOST_REQUIRED');
+    // Claude admission (decision 9095c7a8): the compiled release host, unless a test injects the whole trusted tuple.
+    const claudeProduction = claudeParts === 0 ? createClaudeProductionHost({ home: input.env.HOME ?? '', env: input.env, fetchFn: input.fetchFn,
+        report: event => { process.stderr.write(`${JSON.stringify(event)}\n`); } }) : undefined;
+    const claude = {
+        probe: input.claudeSupportedProbe ?? (() => claudeProduction.probe()),
+        securityHost: input.claudeSecurityHost ?? claudeProduction.securityHost,
+        // Per job: a release change moves the pinned launch path, so the identity is captured at adapter creation.
+        binaryIdentity: async () => input.claudeBinaryIdentity ?? claudeProduction.binaryIdentity(),
+    };
     if (input.codexSupportedProbe && !input.codexSecurityHost)
         throw new Error('CODEX_SUPPORTED_HOST_REQUIRED');
     const production = !input.codexSecurityHost && !input.codexSupportedProbe ? createCodexDaemonHost({ runnerId: input.runnerId, binary: input.env.AI_GATEWAY_LOCAL_RUNNER_CODEX_BINARY ?? 'codex', home: input.env.HOME ?? '', codexHome: input.env.CODEX_HOME, searchPath: input.env.PATH }) : undefined;
@@ -70,12 +81,11 @@ export async function buildDaemon(input) {
     // The same parts the CLI self-test ran before starting this daemon (verifyPackagedHook).
     const hook = packagedHookCommandParts();
     const plugin = new ClaudeCodePlugin({
-        probe: async () => input.claudeSupportedProbe ? input.claudeSupportedProbe() : (await discoverAdapters(input.env, undefined, ['claude_code_cli']))[0],
-        options: ({ worktreePath, jobId }) => createClaudeCodeAdapterOptions({
+        probe: () => claude.probe(),
+        options: async ({ worktreePath, jobId }) => createClaudeCodeAdapterOptions({
             worktreePath, jobId, stateRoot: input.stateRoot, env: input.env,
             maxBudgetUsd: Number.MAX_SAFE_INTEGER, hookExecutablePath: hook.hookScriptPath, hookNodeExecutablePath: hook.nodeExecutablePath,
-            binaryPath: input.env.AI_GATEWAY_LOCAL_RUNNER_CLAUDE_BINARY,
-            securityHost: input.claudeSecurityHost, binaryIdentity: input.claudeBinaryIdentity,
+            securityHost: claude.securityHost, binaryIdentity: await claude.binaryIdentity(),
         }),
     });
     const codex = new CodexPlugin({
@@ -162,24 +172,26 @@ export async function buildDaemon(input) {
         snapshot: async () => {
             // Adapter probes run only between jobs, as they did when the job loop sent the heartbeat.
             if (!poller.running) {
-                const probe = (async () => {
-                    if (input.claudeSupportedProbe) {
-                        let current;
-                        try {
-                            current = await plugin.probe();
-                        }
-                        catch {
-                            current = { available: false, authenticated: false, capabilities: [] };
-                        }
-                        const ready = adapterStatus(current).authenticated && !!current.executableVersion && plugin.capabilities.every(c => current.capabilities.includes(c));
-                        const index = probes.findIndex(p => p.id === 'claude_code_cli');
-                        if (index >= 0)
-                            probes[index] = { id: 'claude_code_cli', version: '1', ...current, available: ready };
-                        if (ready)
-                            versions.claude_code_cli = '1';
-                        else
-                            delete versions.claude_code_cli;
+                // Claude readiness follows the synced release list, so it is refreshed like Codex. The two refreshes run
+                // concurrently and each keeps its own failure handling, so Claude neither delays nor changes the Codex result.
+                const refreshClaude = async () => {
+                    let current;
+                    try {
+                        current = await plugin.probe();
                     }
+                    catch {
+                        current = { available: false, authenticated: false, capabilities: [] };
+                    }
+                    const ready = adapterStatus(current).authenticated && !!current.executableVersion && plugin.capabilities.every(c => current.capabilities.includes(c));
+                    const index = probes.findIndex(p => p.id === 'claude_code_cli');
+                    if (index >= 0)
+                        probes[index] = { id: 'claude_code_cli', version: '1', ...current, available: ready };
+                    if (ready)
+                        versions.claude_code_cli = '1';
+                    else
+                        delete versions.claude_code_cli;
+                };
+                const refreshCodex = async () => {
                     let current;
                     try {
                         current = await codex.probe();
@@ -195,6 +207,14 @@ export async function buildDaemon(input) {
                         versions.codex_cli = '1';
                     else
                         delete versions.codex_cli;
+                };
+                // Both refreshes always run to the end, so a failure outside one never leaves the other writing under a claim;
+                // the first failure then surfaces as it did before.
+                const probe = (async () => {
+                    const settled = await Promise.allSettled([refreshClaude(), refreshCodex()]);
+                    const failed = settled.find((result) => result.status === "rejected");
+                    if (failed)
+                        throw failed.reason;
                 })();
                 probing = probe.catch(() => undefined);
                 await probe;
@@ -231,6 +251,7 @@ export async function buildDaemon(input) {
                 failureCode: result.status === "failed" ? result.failureCode : undefined }, signal);
         },
         guide,
+        ...(claudeProduction ? { claude: claudeProduction } : {}),
         asks,
         closureAcks,
         jobs: poller,
@@ -273,7 +294,18 @@ export async function buildDaemon(input) {
         reportRecoveryRequired: reason => { process.stderr.write(`${JSON.stringify({ event: 'runner_recovery_required', reason })}\n`); },
     });
     // Model tools have no Gateway relay. Each adapter owns and closes its job endpoint.
-    return { daemon, close: async () => { daemon.stop(); await production?.close(); } };
+    // The Claude host always closes; a failing Claude close never masks a Codex close failure.
+    return { daemon, close: async () => {
+            daemon.stop();
+            try {
+                await production?.close();
+            }
+            catch (error) {
+                await claudeProduction?.close().catch(() => undefined);
+                throw error;
+            }
+            await claudeProduction?.close();
+        } };
 }
 export function runnerDisplayName() { return `${hostname()} local AI`; }
 /** The execution blocker a full runner reports for every adapter while it takes no jobs. */
@@ -326,7 +358,7 @@ export function localRunnerCapabilities(probes, trustedLocalFixHost = false, ver
         const status = adapterStatus(probe);
         const authenticated = status.authenticated;
         const capabilities = probe.capabilities.filter(value => value !== 'local_fix_publication_v1' && value !== 'local_fix_gateway_ci_v1' && value !== 'local_fix_gateway_publish_v1');
-        if (trustedLocalFixHost && authenticated && probe.id === 'codex_cli') {
+        if (trustedLocalFixHost && authenticated && isLocalFixAdapter(probe.id)) {
             capabilities.push('local_fix_publication_v1');
             if (verificationMode === 'gateway_ci_v1')
                 capabilities.push('local_fix_gateway_ci_v1');

package/dist/src/gateway-client.js

@@ -1,5 +1,6 @@
 import { publicationError } from './publication/failure.js';
 import { issueTransportDiagnostic } from './safety/transport-diagnostic.js';
+import { parseClaudeSyncRelease } from "./safety/claude-release.js";
 import { createHash } from "node:crypto";
 import { v5 as uuidv5 } from "uuid";
 import { bindingApprovalIdFromEnv, redact } from "./config.js";
@@ -33,6 +34,7 @@ export function parseRunnerSync(result, runnerId) {
         ...(Array.isArray(body.closed_delivery_ids) ? { closedDeliveryIds: body.closed_delivery_ids } : {}),
         ...("guidance_policy" in body ? { guidancePolicy: body.guidance_policy } : {}),
         ...(typeof body.guidance_policy_version === "string" ? { guidancePolicyVersion: body.guidance_policy_version } : {}),
+        ...("claude_release" in body ? { claudeRelease: parseClaudeSyncRelease(body.claude_release) } : {}),
         jobAvailable: body.job_available === true,
         push: parsePush(body.push, runnerId),
         syncSeconds: clampSeconds(body.sync_seconds, 15, 120, 30),

package/dist/src/publication/local-fix-adapters.js

@@ -0,0 +1,4 @@
+/** Runtime adapters whose admitted jobs may use employee-local Fix publication (decision 9095c7a8 adds Claude).
+ * Membership grants nothing alone: each job still needs its adapter's host admission and the Gateway's Fix policy. */
+export const LOCAL_FIX_ADAPTERS = Object.freeze(['codex_cli', 'claude_code_cli']);
+export function isLocalFixAdapter(value) { return typeof value === 'string' && LOCAL_FIX_ADAPTERS.includes(value); }

package/dist/src/publication/production-host.js

@@ -4,6 +4,7 @@ import { lstat, realpath, open, rename, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import { CandidateVerifier, protocolHash } from './candidate.js';
 import { createLocalFixExecutionHost } from './execution-host.js';
+import { isLocalFixAdapter } from './local-fix-adapters.js';
 import { GitSnapshotHost, SNAPSHOT_TREE_MAX_BYTES } from './git-snapshot.js';
 import { createSealedIsolatedVerifier } from './isolated-verifier.js';
 import { FilePublicationJournal } from './journal.js';
@@ -29,7 +30,7 @@ export function createProductionLocalFixHost(options) {
             if (!lifecycle)
                 throw Error('LOCAL_FIX_OWNED_LIFECYCLE_REQUIRED');
             const { job, bindingId } = input, pkg = job.taskPackage, repo = pkg.repository, scope = pkg.local_fix_scope;
-            if (!lifecycle.isCurrent() || repo.provider_url !== options.origin || repo.key !== registration.manifest.project || job.gatewayTaskPackageFingerprint !== protocolHash(pkg) || pkg.runtime_adapter !== 'codex_cli')
+            if (!lifecycle.isCurrent() || repo.provider_url !== options.origin || repo.key !== registration.manifest.project || job.gatewayTaskPackageFingerprint !== protocolHash(pkg) || !isLocalFixAdapter(pkg.runtime_adapter))
                 throw denied();
             const root = await realpath(options.privateRoot), stat = await lstat(root);
             if (root !== options.privateRoot || !stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0 || (process.getuid && stat.uid !== process.getuid()) || root === input.checkoutPath || root.startsWith(input.checkoutPath + path.sep))

package/dist/src/publication/server-ci-host.js

@@ -12,6 +12,7 @@ import { protocolHash } from './candidate.js';
 import { FilePublicationJournal } from './journal.js';
 import { GitSnapshotHost, SNAPSHOT_TREE_MAX_BYTES } from './git-snapshot.js';
 import { PublicationOutcomeUnknownError } from './publisher.js';
+import { isLocalFixAdapter } from './local-fix-adapters.js';
 const denied = () => Error('LOCAL_FIX_SERVER_CI_REJECTED');
 const safePath = (p) => typeof p === 'string' && p.length > 0 && !p.includes('\\') && !p.includes('\0') && !path.isAbsolute(p) && p.split('/').every(s => s !== '' && s !== '.' && s !== '..' && !/^(?:\.git|\.mcp(?:\..*)?|\.npmrc|\.netrc|id_rsa|id_ed25519|\.local-runner|\.runner|\.env(?:\..*)?|\.codex|\.claude|\.ssh|\.aws|\.config|auth\.(?:json|toml|ya?ml)(?:\..*)?|credentials(?:\..*)?|AGENTS\.md|CLAUDE\.md|mcp\.(?:json|toml|ya?ml)(?:\..*)?)$/i.test(s));
 const matches = (p, s) => s.endsWith('/**') ? safePath(s.slice(0, -3)) && (p === s.slice(0, -3) || p.startsWith(s.slice(0, -2))) : safePath(s) && p === s;
@@ -70,7 +71,7 @@ export function createServerCiLocalFixHost(options) {
                 throw denied();
             const { job } = input, pkg = job.taskPackage, scope = pkg.local_fix_scope, repo = pkg.repository, rawLimits = scope?.candidate_limits, allowed = scope?.allowed_paths;
             const root = await realpath(options.privateRoot), st = await lstat(root);
-            if (!lifecycle.isCurrent() || pkg.runtime_adapter !== 'codex_cli' || !scope || scope.verification_mode !== mode || scope.ci_profile_fingerprint !== registration.ci_profile_fingerprint || protocolHash(scope.ci_profile) !== protocolHash(registration.ci_profile) || !Array.isArray(scope.required_commands) || scope.required_commands.length || !scope.registered_tests || typeof scope.registered_tests !== 'object' || Object.keys(scope.registered_tests).length || !Array.isArray(allowed) || !allowed.length || allowed.some(p => typeof p !== 'string' || !(safePath(p) || p.endsWith('/**') && safePath(p.slice(0, -3)))) || protocolHash(allowed) !== protocolHash(pkg.allowed_paths) || repo.key !== registration.project || job.gatewayTaskPackageFingerprint !== protocolHash(pkg) || Object.entries(registration.receipt).some(([k, v]) => scope[k] !== v) || root !== options.privateRoot || !st.isDirectory() || st.isSymbolicLink() || (st.mode & 0o077) !== 0 || (process.getuid && st.uid !== process.getuid()) || root === input.checkoutPath || root.startsWith(input.checkoutPath + path.sep))
+            if (!lifecycle.isCurrent() || !isLocalFixAdapter(pkg.runtime_adapter) || !scope || scope.verification_mode !== mode || scope.ci_profile_fingerprint !== registration.ci_profile_fingerprint || protocolHash(scope.ci_profile) !== protocolHash(registration.ci_profile) || !Array.isArray(scope.required_commands) || scope.required_commands.length || !scope.registered_tests || typeof scope.registered_tests !== 'object' || Object.keys(scope.registered_tests).length || !Array.isArray(allowed) || !allowed.length || allowed.some(p => typeof p !== 'string' || !(safePath(p) || p.endsWith('/**') && safePath(p.slice(0, -3)))) || protocolHash(allowed) !== protocolHash(pkg.allowed_paths) || repo.key !== registration.project || job.gatewayTaskPackageFingerprint !== protocolHash(pkg) || Object.entries(registration.receipt).some(([k, v]) => scope[k] !== v) || root !== options.privateRoot || !st.isDirectory() || st.isSymbolicLink() || (st.mode & 0o077) !== 0 || (process.getuid && st.uid !== process.getuid()) || root === input.checkoutPath || root.startsWith(input.checkoutPath + path.sep))
                 throw denied();
             const limits = candidateLimits(rawLimits, mode === 'gateway_publish_v1');
             const fence = { jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, launchGrant: job.launchGrant, bindingId: input.bindingId };