mtech-ai-local-runner 0.1.48 → 0.1.50

package/README.md

@@ -1,4 +1,37 @@
-## Unreleased: AI-first ask delivery and messenger mode (disabled)
+## 0.1.49: one push transport instead of two long-polls
+
+The daemon no longer long-polls the Gateway (Work Item 25d8ea74). It keeps one Pusher protocol 7 WebSocket to the
+ELSA development Reverb server, which only rings, and calls `local_agent_runner_sync` once, with no wait: on start,
+after each subscribe, on each signal, every 30 s while subscribed, and every 8 s while the socket is down or the
+Gateway gives no push block. A job is claimed with `local_agent_jobs_wait` at `wait_seconds` 0, and only when the
+sync says one is claimable. Session opens, ask deliveries and closures arrive on the sync result, and a closure is
+acknowledged on the next sync. The full heartbeat goes out on a change or every 10 minutes. While the daemon takes no
+jobs (reconciling at start, or suspended for recovery), it reports every adapter blocked with
+`RUNNER_NOT_ACCEPTING_JOBS`, so the Gateway routes no job to it.
+
+The socket sends `User-Agent: mtec-ai-local-runner/<version>`; the server's firewall refuses an upgrade without one.
+The runner needs a Gateway with `local_agent_runner_sync` and `local_agent_runner_channel_auth`, so deploy the
+Gateway before upgrading a runner. Push stays off until the Gateway's push switch names the employee; until then the
+runner syncs every 8 s.
+
+## 0.1.48: local_edit takes the complete file, not a patch
+
+Read the existing file first, then pass its complete desired new contents in
+`local_edit.content`, including unchanged text. The operation replaces the whole
+file or creates it; it never applies a diff. Recognizable apply_patch directives,
+unified hunk lines and diff headers return `DENIED_PATCH_CONTENT` before a write.
+The isolated writer enforces the same guard. Literal patch blocks in a document
+are also rejected by this conservative API; ordinary source string literals and
+YAML separators remain accepted. No partial old/new edit tool is introduced.
+
+Gateway and Runner must agree on the new tool inventory hash. Package runtime
+receipts change, while the reviewed Codex CLI release manifest identity stays
+unchanged. Keep existing -2G allowed paths; deploy the matching Gateway registry
+and exact runtime pins before switching a daemon. The candidate contains the
+newer development ask/messenger code documented below and
+the 0.1.46/0.1.47 fixes; no integration is installed merely by preparing it.
+
+### Also in 0.1.48: AI-first ask delivery and messenger mode (disabled)
 
 The runner can put an AI Gateway ask (a Work Decision, a named review or a work request), and the answer to it,
 into the employee's own running Claude Code or Codex session before any Slack message is sent (Work Item e1c08b33,
@@ -70,23 +103,6 @@ its pilot list. Until then an existing runner works as before: setup never turns
 installs no integration it was not asked for. The one change without the switch is that setup on a fresh Mac without an
 admitted executor completes as a messenger instead of failing. Deploy the Gateway receivers before upgrading a runner.
 
-## 0.1.48: local_edit takes the complete file, not a patch
-
-Read the existing file first, then pass its complete desired new contents in
-`local_edit.content`, including unchanged text. The operation replaces the whole
-file or creates it; it never applies a diff. Recognizable apply_patch directives,
-unified hunk lines and diff headers return `DENIED_PATCH_CONTENT` before a write.
-The isolated writer enforces the same guard. Literal patch blocks in a document
-are also rejected by this conservative API; ordinary source string literals and
-YAML separators remain accepted. No partial old/new edit tool is introduced.
-
-Gateway and Runner must agree on the new tool inventory hash. Package runtime
-receipts change, while the reviewed Codex CLI release manifest identity stays
-unchanged. Keep existing -2G allowed paths; deploy the matching Gateway registry
-and exact runtime pins before switching a daemon. The candidate contains the
-newer development ask/messenger code documented in the Unreleased section and
-the 0.1.46/0.1.47 fixes; no integration is installed merely by preparing it.
-
 ## 0.1.47: Claude security host wiring remains gated
 
 Claude now shares the job security session and checks a live opaque executable
@@ -766,3 +782,9 @@ 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.
+
+### 0.1.50: small edits and publication-only Fix
+
+Use `local_replace({path, old, new})` for a small approved edit after reading the file: `old` must be nonempty and match exactly once, including whitespace. Zero or overlapping/multiple matches are rejected with distinct errors and no write. Replacement text must not be a patch; the result retains the same scoped write, size, link and revocation protections as `local_edit`. `local_edit` remains a complete-file replacement API.
+
+Both CLI adapters require the five-tool inventory. Gateway tools descriptors and runtime pins must match this release; CLI release manifests and the standalone binary stay fixed. In `gateway_publish_v1`, missing registered tests is expected: report not_run/unverified, apply only the smallest source-evidenced correction, disclose uncertainty and seal for a human-reviewed Gateway PR. Historical contracts and attempts are not edited. Reverb 0.1.49 is retained; installation, deployment and real model execution remain separate approvals.

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

@@ -12,7 +12,7 @@ import { formatHookCommand } from "../../safety/hook-command.js";
 import { localEndpointReadObservations } from '../../safety/local-tool-server.js';
 const ALLOWED_ENV_KEYS = ["PATH", "HOME", "USER", "LOGNAME", "LANG", "LC_ALL", "TMPDIR", "NODE_ENV", "CLAUDE_CONFIG_DIR"];
 const ALLOWED_SUPERVISOR_COMMANDS = new Set(["continue", "answer_question", "request_revision", "request_checkpoint", "submit_for_review"]);
-const LOCAL_NAMES = ["local_read", "local_search", "local_edit", "local_test"].map(name => `mcp__ai_local__${name}`);
+const LOCAL_NAMES = ["local_read", "local_search", "local_edit", "local_replace", "local_test"].map(name => `mcp__ai_local__${name}`);
 function allowlistedEnv(env) {
     const result = {};
     for (const key of ALLOWED_ENV_KEYS) {

package/dist/src/adapters/codex/config-builder.js

@@ -22,7 +22,7 @@ export function buildCodexInvocation(input) {
         `permissions.local_job.filesystem={":minimal"="read",${deniedFiles}}`,
         "permissions.local_job.network.enabled=false",
         // Only this job server is preauthorized: every operation is checked by Runner policy.
-        `mcp_servers={ai_local={url=${JSON.stringify(endpoint.toString())},bearer_token_env_var="AI_GATEWAY_JOB_MCP_TOKEN",required=true,default_tools_approval_mode="approve",enabled_tools=["local_read","local_search","local_edit","local_test"],omit_tools_from=${JSON.stringify(CODEX_JOB_MCP_OMIT_SURFACES)}}}`,
+        `mcp_servers={ai_local={url=${JSON.stringify(endpoint.toString())},bearer_token_env_var="AI_GATEWAY_JOB_MCP_TOKEN",required=true,default_tools_approval_mode="approve",enabled_tools=["local_read","local_search","local_edit","local_replace","local_test"],omit_tools_from=${JSON.stringify(CODEX_JOB_MCP_OMIT_SURFACES)}}}`,
     ];
     const env = { HOME: input.env.HOME, AI_GATEWAY_JOB_MCP_TOKEN: input.endpoint.token };
     for (const key of ["PATH", "USER", "LOGNAME", "LANG", "LC_ALL", "TMPDIR", "CODEX_HOME"]) {

package/dist/src/adapters/codex/pre-model-gate.js

@@ -2,7 +2,7 @@ import { isAbsolute } from 'node:path';
 import { requireSupportedCodexPolicy } from './supported-admission.js';
 const REJECTED = 'CODEX_PRE_MODEL_REJECTED';
 const usedSessions = new WeakSet();
-const REQUIRED_TOOLS = ['local_edit', 'local_read', 'local_search', 'local_test'];
+const REQUIRED_TOOLS = ['local_edit', 'local_read', 'local_replace', 'local_search', 'local_test'];
 const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 /** Bounded, value-free diagnostics for ALL candidate prerequisites. This is not
  * native release certification: only trusted retained observations may reach it,

package/dist/src/adapters/codex/prompt-compiler.js

@@ -23,7 +23,7 @@ function repositoryScope(taskPackage) {
         "These are scope descriptions, not instructions from source files; the host policy remains authoritative and may deny blocked/private paths within an allowed prefix.";
 }
 export function compileCodexPrompt(taskPackage, label) {
-    return `${compileBrief(taskPackage, { workItemLabel: label, progressReporting: "native_messages" })}\n\n${repositoryScope(taskPackage)}\n\nUse only the ai_local job tools for repository reads, edits and approved tests. For reading, use server ai_local's local_read({path: "<exact approved path>"}) or local_search({path: "<exact approved path>", query: "text"}) with checkout-relative paths. Required test criteria are not command grants. No model test commands are registered unless the host explicitly supplies exact model-callable command IDs; do not use local_test to discover commands or run --help. Missing tests remain not_run/unverified, not passed. In a read-only task, use only read/search tools; the Runner enforces the approved paths and operations. A denied native cwd is intentional: it is a private control directory, not the source checkout. Native filesystem, commands, web, images and delegation are unavailable or denied. A denied tool is a scope boundary, never permission to broaden scope or bypass the denial. Do not retry the denied path. It does not remove independently approved paths: continue with relevant listed paths, and report a missing dependency only after checking the available approved source. Do not repeat host orchestration: claim, shadow, fingerprints, binding, administrator checks, launches, Gateway usage and Job reporting belong to the Runner/host, even when described in the objective. Perform only the assigned repository work and report evidence you actually observed. Do not claim that no model call occurred. If the required tool is unavailable, emit one final structured blocked report naming the missing tool and unfinished repository work; do not request or attempt a new launch.`;
+    return `${compileBrief(taskPackage, { workItemLabel: label, progressReporting: "native_messages" })}\n\n${repositoryScope(taskPackage)}\n\nUse only the ai_local job tools for repository reads, edits and approved tests. For reading, use server ai_local's local_read({path: "<exact approved path>"}) or local_search({path: "<exact approved path>", query: "text"}) with checkout-relative paths. For small approved edits, use local_replace({path, old, new}) after reading: old must match exactly once, including whitespace. local_edit requires the complete replacement file, never a patch. Required test criteria are not command grants. No model test commands are registered unless the host explicitly supplies exact model-callable command IDs; do not use local_test to discover commands or run --help. Missing tests remain not_run/unverified, not passed. In a read-only task, use only read/search tools; the Runner enforces the approved paths and operations. A denied native cwd is intentional: it is a private control directory, not the source checkout. Native filesystem, commands, web, images and delegation are unavailable or denied. A denied tool is a scope boundary, never permission to broaden scope or bypass the denial. Do not retry the denied path. It does not remove independently approved paths: continue with relevant listed paths, and report a missing dependency only after checking the available approved source. Do not repeat host orchestration: claim, shadow, fingerprints, binding, administrator checks, launches, Gateway usage and Job reporting belong to the Runner/host, even when described in the objective. Perform only the assigned repository work and report evidence you actually observed. Do not claim that no model call occurred. If the required tool is unavailable, emit one final structured blocked report naming the missing tool and unfinished repository work; do not request or attempt a new launch.`;
 }
 export const CODEX_REPORT_SCHEMA = {
     type: "object", additionalProperties: false, required: ["status", "report", "evidence", "pending_work"],

package/dist/src/asks/messenger.js

@@ -5,16 +5,22 @@ import { Daemon } from "../daemon/daemon.js";
 import { ProcessLock } from "../daemon/process-lock.js";
 import { runnerDisplayName } from "../daemon/runtime.js";
 import { SessionOpener, sessionOpenAdvertisement } from "../daemon/session-opener.js";
-import { SessionOpenPoller, abortableDelay } from "../daemon/session-open-poller.js";
+import { RunnerTransport } from "../transport/runner-transport.js";
+import { ReverbSocket } from "../transport/reverb-socket.js";
+import { PendingClosureAcks, createSyncDispatcher } from "../transport/sync-dispatch.js";
+import { abortableDelay } from "../transport/abortable-delay.js";
+import { sideLoops, tickingHeartbeat } from "../transport/side-loops.js";
 import { packageVersion } from "../package-version.js";
 import { AskRuntime, withAsks } from "./runtime.js";
 /*
  * Messenger mode (Work Item e1c08b33, spec section 8.1). Setup chose it because no executor is admitted on
- * this Mac. The daemon runs the session-open loop only: there is no jobs loop, no adapter probe, no PreToolUse
- * self-test and no executor host, so nothing built here can start an executor.
+ * this Mac. The daemon runs the push transport only (Work Item 25d8ea74): there is no jobs loop, no adapter probe,
+ * no PreToolUse self-test and no executor host, so nothing built here can start an executor.
  */
-/** A messenger has no jobs loop, so its session-open loop sends the heartbeat: at daemon start, then every 600 s. */
+/** A messenger has no jobs loop, so it sends the heartbeat itself: at daemon start, then every 600 s. */
 export const MESSENGER_HEARTBEAT_MS = 600_000;
+/** How often the heartbeat decides whether a beat is due (Work Item 25d8ea74); it used to run on every wait. */
+export const MESSENGER_HEARTBEAT_TICK_MS = 30_000;
 const HEARTBEAT_RETRY_MS = 60_000;
 /**
  * The waits before resending a heartbeat that had to leave session_open out, one after another: 60, 120, 240 s, then the
@@ -108,21 +114,42 @@ export async function buildMessengerDaemon(input) {
     }, { now: input.now, reportError: code => log({ event: "messenger_heartbeat_failed", code }),
         advertised: async () => JSON.stringify(await asks.advertisement() ?? null) });
     const opener = new SessionOpener({ home });
-    const sessionOpens = new SessionOpenPoller({
-        wait: async (signal) => {
-            await heartbeat(signal);
-            const result = await gateway.waitForSessionOpens(25, signal);
-            await asks.handleWait(result);
-            return result;
-        },
+    const stopping = new AbortController();
+    const closureAcks = new PendingClosureAcks();
+    const dispatch = createSyncDispatcher({
         open: request => opener.open(request),
         report: async (openId, result, signal) => {
             await gateway.reportSessionOpen({ openId, status: result.status, surface: result.surface,
                 failureCode: result.status === "failed" ? result.failureCode : undefined }, signal);
         },
+        asks,
+        closureAcks,
         delay: abortableDelay,
+        signal: stopping.signal,
         reportError: diagnostic => log({ event: "session_open_poller_failed", ...diagnostic }),
     });
+    // No executor: the messenger sends no adapter versions, and the Gateway never says a job is claimable.
+    const transport = new RunnerTransport({
+        sync: async (reason, signal) => {
+            const acknowledged = closureAcks.take();
+            try {
+                return await gateway.syncRunner({ adapterVersions: {}, reason, acknowledgedClosureIds: acknowledged }, signal);
+            }
+            catch (error) {
+                closureAcks.restore(acknowledged);
+                throw error;
+            }
+        },
+        authorize: (socketId, signal) => gateway.authorizeRunnerChannel(socketId, signal),
+        dispatch,
+        openSocket: (target, events) => new ReverbSocket(target, events, { packageVersion: packageVersion() }),
+        report: log,
+    });
+    const sessionOpens = sideLoops({
+        heartbeat: tickingHeartbeat(heartbeat, input.heartbeatTickMs ?? MESSENGER_HEARTBEAT_TICK_MS, stopping.signal),
+        transport,
+        onStop: () => stopping.abort(),
+    });
     const daemon = new Daemon({
         lock: new ProcessLock(join(input.stateRoot, "daemon.lock")),
         // Job state belongs to a full runner: a messenger never reads, reconciles or suspends on it.

package/dist/src/asks/runtime.js

@@ -102,17 +102,24 @@ export class AskRuntime {
      * the runner's person is a pilot actor and it has stored this runner's ask_inbox. A result without ask_deliveries
      * therefore means asks are off, and every stored delivery ends here with no report: the Gateway's fallback owns them.
      * A result with the key present but empty changes nothing.
+     *
+     * Resolves false when the result's closures could not be handled (the hub is down, or closing failed), so the push
+     * transport does not acknowledge them and the Gateway lists them again (Work Item 25d8ea74).
      */
     async handleWait(result) {
         if (!this.started)
-            return;
+            return false;
+        let closuresHandled = true;
         try {
             if (result.askDeliveries === undefined) {
                 await this.inbox.endAll();
-                return;
+                return true;
             }
-            if (result.closedDeliveryIds !== undefined && result.closedDeliveryIds.length > 0)
+            if (result.closedDeliveryIds !== undefined && result.closedDeliveryIds.length > 0) {
+                closuresHandled = false;
                 await this.inbox.close(result.closedDeliveryIds);
+                closuresHandled = true;
+            }
             if (result.askDeliveries.length > 0)
                 await this.inbox.receive(result.askDeliveries);
         }
@@ -120,6 +127,7 @@ export class AskRuntime {
             this.log({ event: "ask_delivery_failed", code: errorCode(error) });
         }
         this.flushSoon();
+        return closuresHandled;
     }
     /**
      * heartbeat runner.session_open.ask_inbox, or undefined when the hub is down or nothing is installed. While a start is

package/dist/src/daemon/heartbeat-scheduler.js

@@ -0,0 +1,63 @@
+export class HeartbeatScheduler {
+    deps;
+    lastKey;
+    lastSentAt = Number.NEGATIVE_INFINITY;
+    timer;
+    stopped = false;
+    chain = Promise.resolve();
+    release;
+    done = new Promise(resolve => { this.release = resolve; });
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** One heartbeat check now, after any check in progress; never throws. */
+    tick() {
+        this.chain = this.chain.then(() => this.check());
+        return this.chain;
+    }
+    async check() {
+        let snapshot;
+        try {
+            snapshot = await this.deps.snapshot();
+        }
+        catch {
+            this.report("HEARTBEAT_SNAPSHOT_FAILED");
+            return;
+        }
+        const key = JSON.stringify(snapshot);
+        const now = (this.deps.now ?? Date.now)();
+        if (key === this.lastKey && now - this.lastSentAt < (this.deps.maxAgeMs ?? 600_000))
+            return;
+        try {
+            await this.deps.send(snapshot);
+            this.lastKey = key;
+            this.lastSentAt = now;
+        }
+        catch {
+            this.report("HEARTBEAT_SEND_FAILED");
+        }
+    }
+    /** Keeps ticking until stop(). The first tick comes one interval in: the caller sends the first heartbeat itself. */
+    async run() {
+        const loop = () => {
+            if (this.stopped)
+                return;
+            this.timer = setTimeout(() => { void this.tick().then(loop); }, this.deps.intervalMs ?? 60_000);
+        };
+        loop();
+        await this.done;
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        clearTimeout(this.timer);
+        this.release();
+    }
+    report(code) {
+        try {
+            this.deps.reportError?.(code);
+        }
+        catch { /* Logging cannot stop heartbeats. */ }
+    }
+}

package/dist/src/daemon/job-runner.js

@@ -0,0 +1,99 @@
+export class JobRunner {
+    deps;
+    armed = false;
+    busy = false;
+    pending = false;
+    stopped = false;
+    inFlight;
+    release;
+    done = new Promise(resolve => { this.release = resolve; });
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** True while a claim or a job is in progress. */
+    get running() {
+        return this.busy;
+    }
+    /**
+     * True while this runner may claim: after run() started and before stop(). A runner that does not accept jobs
+     * (still reconciling, or suspended after an unknown outcome) must not look ready to the Gateway.
+     */
+    get accepting() {
+        return this.armed && !this.stopped;
+    }
+    notify() {
+        if (this.stopped)
+            return;
+        if (!this.armed || this.busy) {
+            this.pending = true;
+            return;
+        }
+        this.start();
+    }
+    async run() {
+        // A pending promise alone does not keep Node alive; this referenced timer does until stop().
+        const keepAlive = setInterval(() => undefined, 60_000);
+        try {
+            this.armed = true;
+            if (!this.stopped) {
+                try {
+                    this.deps.onArmed?.();
+                }
+                catch { /* Telling the Gateway is best effort; claims still start. */ }
+            }
+            if (this.pending && !this.stopped) {
+                this.pending = false;
+                this.start();
+            }
+            await this.done;
+            // Like the old poll loop, run() ends only after the claim or job in progress has finished.
+            await this.inFlight;
+        }
+        finally {
+            clearInterval(keepAlive);
+        }
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.release();
+    }
+    start() {
+        const cycle = this.cycle();
+        this.inFlight = cycle;
+        void cycle.finally(() => { if (this.inFlight === cycle)
+            this.inFlight = undefined; });
+    }
+    async cycle() {
+        this.busy = true;
+        let stage = "claim";
+        try {
+            const claim = await this.deps.claim();
+            if (claim.status === "claimed" && claim.job !== undefined && !this.stopped) {
+                stage = "execute";
+                await this.deps.execute(claim.job);
+                this.deps.requestSync("after_job");
+            }
+        }
+        catch {
+            try {
+                this.deps.reportError?.({ stage, code: stage === "execute" ? "EXECUTION_UNACKNOWLEDGED" : "GATEWAY_UNAVAILABLE" });
+            }
+            catch { /* Observational logging cannot bypass the stop below or discard recovery state. */ }
+            // Unknown execution or terminal outcomes must reconcile before any new claim.
+            if (stage === "execute") {
+                this.busy = false;
+                this.stop();
+                return;
+            }
+        }
+        finally {
+            this.busy = false;
+        }
+        if (this.pending && !this.stopped) {
+            this.pending = false;
+            this.start();
+        }
+    }
+}

package/dist/src/daemon/runtime.js

@@ -17,11 +17,16 @@ import { WorkspaceManager } from "../workspace/workspace-manager.js";
 import { GitClient } from "../workspace/git-client.js";
 import { FileDaemonStateStore } from "../state-store.js";
 import { ExecutionCoordinator } from "./execution-coordinator.js";
-import { JobPoller } from "./job-poller.js";
+import { JobRunner } from "./job-runner.js";
+import { HeartbeatScheduler } from "./heartbeat-scheduler.js";
 import { ProcessLock } from "./process-lock.js";
 import { Daemon } from "./daemon.js";
 import { SessionOpener, sessionOpenAdvertisement } from "./session-opener.js";
-import { SessionOpenPoller, abortableDelay } from "./session-open-poller.js";
+import { RunnerTransport } from "../transport/runner-transport.js";
+import { ReverbSocket } from "../transport/reverb-socket.js";
+import { PendingClosureAcks, createSyncDispatcher } from "../transport/sync-dispatch.js";
+import { abortableDelay } from "../transport/abortable-delay.js";
+import { sideLoops } from "../transport/side-loops.js";
 import { buildTerminalEvidenceCollector } from "../safety/terminal-evidence.js";
 import { packagedHookCommandParts } from "../safety/hook-command.js";
 import { composeReviewedP1Host } from '../verification/p1-host-composition.js';
@@ -115,60 +120,15 @@ export async function buildDaemon(input) {
         workspaces: new WorkspaceManager({ root: input.workspaceRoot, git: new GitClient() }),
         state,
     });
-    const poller = new JobPoller({
+    let transport;
+    /** The adapter probe in progress, if any: a claim waits for it, so versions never change under a claim. */
+    let probing = Promise.resolve();
+    const poller = new JobRunner({
         reportError: (diagnostic) => { process.stderr.write(`${JSON.stringify({ event: "poller_failed", ...diagnostic })}\n`); },
-        heartbeat: 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;
-            }
-            let current;
-            try {
-                current = await codex.probe();
-            }
-            catch {
-                current = { available: false, authenticated: false, capabilities: [] };
-            }
-            const ready = adapterStatus(current).authenticated && !!current.executableVersion && codex.capabilities.every(c => current.capabilities.includes(c));
-            const index = probes.findIndex(p => p.id === 'codex_cli');
-            if (index >= 0)
-                probes[index] = { id: 'codex_cli', version: '1', ...current, available: ready };
-            if (ready)
-                versions.codex_cli = '1';
-            else
-                delete versions.codex_cli;
-            let sessionOpen;
-            // A detection error must not stop job claims: the heartbeat simply omits the field.
-            try {
-                sessionOpen = await sessionOpenAdvertisement({ home: input.env.HOME ?? "" });
-            }
-            catch {
-                sessionOpen = undefined;
-            }
-            const askInbox = await asks.advertisement();
-            await gateway.heartbeatLocalRunner({
-                deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${input.gatewayMcpUrl}`).digest("hex"),
-                displayName: runnerDisplayName(), packageVersion: packageVersion(),
-                capabilities: localRunnerCapabilities(probes, !!localFixHost, localFixHost?.verificationMode),
-                mode: "full",
-                ...(sessionOpen ? { sessionOpen: { ...sessionOpen, ...(askInbox ? { ask_inbox: askInbox } : {}) } } : {}),
-            });
-        },
-        wait: async () => {
-            const claim = await gateway.waitForLocalJob(versions, 25);
+        // Push transport (Work Item 25d8ea74): claimed only when a sync says a job is claimable, with no wait.
+        claim: async () => {
+            await probing;
+            const claim = await gateway.waitForLocalJob(versions, 0);
             if (claim.status !== "claimed" || !claim.job || !claim.task_package || !claim.lease_token || !claim.launch_grant)
                 return { status: "no_job" };
             if (production && claim.task_package.runtime_adapter === 'codex_cli')
@@ -186,23 +146,107 @@ export async function buildDaemon(input) {
         execute: async (job) => {
             await coordinator.execute(job);
         },
-        delay: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+        requestSync: reason => { transport?.requestSync(reason); },
+        // Until now the heartbeat said this runner takes no jobs; tell the Gateway at once, and ask whether one waits.
+        onArmed: () => { void heartbeats.tick(); transport?.requestSync("start"); },
     });
-    const opener = new SessionOpener({ home: input.env.HOME ?? "" });
-    const sessionOpens = new SessionOpenPoller({
-        wait: async (signal) => {
-            const result = await gateway.waitForSessionOpens(25, signal);
-            await asks.handleWait(result);
-            return result;
+    const heartbeats = new HeartbeatScheduler({
+        intervalMs: 30_000,
+        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;
+                    }
+                    let current;
+                    try {
+                        current = await codex.probe();
+                    }
+                    catch {
+                        current = { available: false, authenticated: false, capabilities: [] };
+                    }
+                    const ready = adapterStatus(current).authenticated && !!current.executableVersion && codex.capabilities.every(c => current.capabilities.includes(c));
+                    const index = probes.findIndex(p => p.id === 'codex_cli');
+                    if (index >= 0)
+                        probes[index] = { id: 'codex_cli', version: '1', ...current, available: ready };
+                    if (ready)
+                        versions.codex_cli = '1';
+                    else
+                        delete versions.codex_cli;
+                })();
+                probing = probe.catch(() => undefined);
+                await probe;
+            }
+            let sessionOpen;
+            // A detection error must not stop job claims: the heartbeat simply omits the field.
+            try {
+                sessionOpen = await sessionOpenAdvertisement({ home: input.env.HOME ?? "" });
+            }
+            catch {
+                sessionOpen = undefined;
+            }
+            const askInbox = await asks.advertisement();
+            return {
+                deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${input.gatewayMcpUrl}`).digest("hex"),
+                displayName: runnerDisplayName(), packageVersion: packageVersion(),
+                capabilities: acceptingJobs(localRunnerCapabilities(probes, !!localFixHost, localFixHost?.verificationMode), poller.accepting),
+                mode: "full",
+                ...(sessionOpen ? { sessionOpen: { ...sessionOpen, ...(askInbox ? { ask_inbox: askInbox } : {}) } } : {}),
+            };
         },
+        send: async (payload) => { await gateway.heartbeatLocalRunner(payload); },
+        reportError: code => { process.stderr.write(`${JSON.stringify({ event: "heartbeat_failed", code })}\n`); },
+    });
+    const stopping = new AbortController();
+    const closureAcks = new PendingClosureAcks();
+    const opener = new SessionOpener({ home: input.env.HOME ?? "" });
+    const dispatch = createSyncDispatcher({
         open: request => opener.open(request),
         report: async (openId, result, signal) => {
             await gateway.reportSessionOpen({ openId, status: result.status, surface: result.surface,
                 failureCode: result.status === "failed" ? result.failureCode : undefined }, signal);
         },
+        asks,
+        closureAcks,
+        jobs: poller,
         delay: abortableDelay,
+        signal: stopping.signal,
         reportError: diagnostic => { process.stderr.write(`${JSON.stringify({ event: "session_open_poller_failed", ...diagnostic })}\n`); },
     });
+    const pushTransport = new RunnerTransport({
+        sync: async (reason, signal) => {
+            const acknowledged = closureAcks.take();
+            // A runner that takes no jobs right now (reconciling, or suspended for recovery) names no adapter.
+            try {
+                return await gateway.syncRunner({ adapterVersions: poller.accepting ? versions : {}, reason, acknowledgedClosureIds: acknowledged }, signal);
+            }
+            catch (error) {
+                closureAcks.restore(acknowledged);
+                throw error;
+            }
+        },
+        authorize: (socketId, signal) => gateway.authorizeRunnerChannel(socketId, signal),
+        dispatch,
+        openSocket: (target, events) => new ReverbSocket(target, events, { packageVersion: packageVersion() }),
+        report: event => { process.stderr.write(`${JSON.stringify(event)}\n`); },
+    });
+    transport = pushTransport;
+    const sessionOpens = sideLoops({ heartbeat: heartbeats, transport: pushTransport, onStop: () => stopping.abort() });
     const daemon = new Daemon({
         lock: new ProcessLock(join(input.stateRoot, "daemon.lock")), state,
         reconcile: async (stored) => {
@@ -222,6 +266,20 @@ export async function buildDaemon(input) {
     return { daemon, close: async () => { daemon.stop(); await production?.close(); } };
 }
 export function runnerDisplayName() { return `${hostname()} local AI`; }
+/** The execution blocker a full runner reports for every adapter while it takes no jobs. */
+export const RUNNER_NOT_ACCEPTING_JOBS = "RUNNER_NOT_ACCEPTING_JOBS";
+/*
+ * Work Item 25d8ea74: sync keeps presence fresh even while the daemon reconciles or is suspended for recovery, which
+ * the old job loop's heartbeat never did. So the heartbeat itself must say the runner takes no jobs, or the Gateway
+ * would route a job to a runner that never claims it. The Gateway requires at least one capability from a full
+ * runner, so each adapter is reported blocked, with this code, instead of being left out.
+ */
+export function acceptingJobs(capabilities, accepting) {
+    if (accepting)
+        return capabilities;
+    return capabilities.map(capability => ({ ...capability, authenticated: false, execution_status: "blocked",
+        execution_reason_codes: [...new Set([RUNNER_NOT_ACCEPTING_JOBS, ...capability.execution_reason_codes])].slice(0, 20) }));
+}
 /** Unknown mutation outcomes halt polling; known failures replay only their terminal receipt. */
 export async function reconcilePreparationState(previous, deps) {
     if (["publication_pending", "publication_terminal_pending"].includes(previous.phase ?? ""))