mtech-ai-local-runner 0.1.74 → 0.1.75

package/README.md

@@ -525,6 +525,13 @@ publication authority through a late response. Once publication may have taken
 effect, retain `publication_pending` recovery instead of falsely completing,
 failing or restarting the attempt. Canonical publication approval remains required.
 
+Since 0.1.75 (Work Decision `b3d7eb22`) a failed Gateway stage, advance or fence read
+after stage started is repeated with the same arguments for up to 15 minutes, 5 s
+doubling to 130 s, while the heartbeat keeps the lease. A suspended runner names its
+held publication job in `suspended_job` on sync. Once the Gateway answers that the job
+is closed, it clears its state and restarts. The Gateway closes only that runner's own
+job, only when its lease is long expired and no pull request can exist.
+
 Component, shadow admission, installed-package and live-provider evidence are
 separate. Historical 0.1.10 hook behavior below is not current Claude admission;
 Claude parity requires the actual current isolation/admission gate to pass.

package/dist/src/daemon/runtime.js

@@ -35,6 +35,7 @@ import { composeReviewedP1Host } from '../verification/p1-host-composition.js';
 import { AskRuntime, withAsks } from '../asks/runtime.js';
 import { GuideRuntime, withGuide } from '../guide/runtime.js';
 import { FixConsentRuntime } from './fix-consent.js';
+import { SuspendedPublication } from './suspended-publication.js';
 import { RoomActivityRuntime } from '../rooms/activity.js';
 import { notifyRoomActivity } from '../rooms/notifier.js';
 export async function buildDaemon(input) {
@@ -267,6 +268,9 @@ export async function buildDaemon(input) {
         report: () => localFixHost?.report, jobRunning: () => poller.running,
         restart: () => { daemon.stop(); },
         log: event => { process.stderr.write(`${JSON.stringify(event)}\n`); } });
+    // A suspended publication clears itself once the Gateway closed its job (Work Decision b3d7eb22), then restarts like a consent change.
+    const suspendedPublication = new SuspendedPublication({ state, restart: () => { daemon.stop(); },
+        log: event => { process.stderr.write(`${JSON.stringify(event)}\n`); } });
     const opener = new SessionOpener({ home: input.env.HOME ?? "" });
     const dispatch = createSyncDispatcher({
         open: request => opener.open(request),
@@ -289,9 +293,10 @@ export async function buildDaemon(input) {
     const pushTransport = new RunnerTransport({
         sync: async (reason, signal) => {
             const acknowledged = closureAcks.take();
+            const suspendedJob = await suspendedPublication.named();
             // 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, guidancePolicyVersion: await guide.policyVersion(), roomActivityV1: true }, signal);
+                return await gateway.syncRunner({ adapterVersions: poller.accepting ? versions : {}, reason, acknowledgedClosureIds: acknowledged, guidancePolicyVersion: await guide.policyVersion(), roomActivityV1: true, ...(suspendedJob ? { suspendedJob } : {}) }, signal);
             }
             catch (error) {
                 closureAcks.restore(acknowledged);
@@ -307,7 +312,12 @@ export async function buildDaemon(input) {
                 await dispatch(result);
             }
             finally {
-                await fixConsent.afterSync(result);
+                try {
+                    await fixConsent.afterSync(result);
+                }
+                finally {
+                    await suspendedPublication.afterSync(result);
+                }
             }
         },
         openSocket: (target, events) => new ReverbSocket(target, events, { packageVersion: packageVersion() }),
@@ -328,7 +338,7 @@ export async function buildDaemon(input) {
             throw new Error('Runner state requires authoritative reconciliation');
         },
         poller, sessionOpens: withGuide(guide, withAsks(asks, sessionOpens)),
-        reportRecoveryRequired: reason => { process.stderr.write(`${JSON.stringify({ event: 'runner_recovery_required', reason })}\n`); },
+        reportRecoveryRequired: reason => { suspendedPublication.markSuspended(); 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.
     // The Claude host always closes; a failing Claude close never masks a Codex close failure.

package/dist/src/daemon/suspended-publication.js

@@ -0,0 +1,52 @@
+const PUBLICATION_PHASES = ["publication_pending", "publication_terminal_pending"];
+/** The job fence of a stored publication phase, or undefined for any other state. */
+function heldPublication(state) {
+    if (!state || typeof state !== "object" || Array.isArray(state))
+        return undefined;
+    const { phase, jobId, generation } = state;
+    if (typeof phase !== "string" || !PUBLICATION_PHASES.includes(phase))
+        return undefined;
+    if (typeof jobId !== "string" || !jobId.trim() || !Number.isSafeInteger(generation) || generation < 1)
+        return undefined;
+    return { jobId, generation: generation };
+}
+export class SuspendedPublication {
+    deps;
+    suspended = false;
+    cleared = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** The daemon suspended for recovery; from now on its held publication is named. */
+    markSuspended() { this.suspended = true; }
+    /** The job to name on the next sync. A state that cannot be read names nothing. */
+    async named() {
+        if (!this.suspended || this.cleared)
+            return undefined;
+        try {
+            return heldPublication(await this.deps.state.load());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** After every sync: clears and restarts only when the answer closes the job the state still holds. */
+    async afterSync(result) {
+        const answer = result.suspendedJob;
+        if (!answer?.closed)
+            return;
+        const held = await this.named();
+        if (!held || held.jobId !== answer.jobId || held.generation !== answer.generation)
+            return;
+        try {
+            await this.deps.state.clear();
+        }
+        catch {
+            this.deps.log({ event: "runner_recovery_clear_failed", job_id: held.jobId, generation: held.generation });
+            return;
+        }
+        this.cleared = true;
+        this.deps.log({ event: "runner_recovery_cleared", job_id: held.jobId, generation: held.generation, gateway_status: answer.status });
+        this.deps.restart();
+    }
+}

package/dist/src/gateway-client.js

@@ -19,6 +19,17 @@ export class GatewayToolError extends Error {
     }
 }
 const ROOM_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SUSPENDED_JOB_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** A malformed answer is dropped, never a reason to refuse the sync: the runner then stays suspended. */
+function parseSuspendedJob(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const { job_id: jobId, generation, status, closed } = value;
+    if (typeof jobId !== "string" || !SUSPENDED_JOB_ID.test(jobId) || !Number.isSafeInteger(generation) || generation < 1
+        || typeof status !== "string" || !/^[a-z_]{1,32}$/.test(status) || typeof closed !== "boolean")
+        return undefined;
+    return { jobId, generation: generation, status, closed };
+}
 const FIX_CONSENT_GRANT_ID = /^[a-zA-Z0-9-]{1,64}$/;
 const FIX_CONSENT_REPOSITORY_KEY = /^[a-z0-9][a-z0-9._-]{0,99}$/;
 const FIX_CONSENT_GRANTS_MAX = 20;
@@ -54,6 +65,7 @@ export function parseRunnerSync(result, runnerId) {
     if (body === undefined || !Array.isArray(body.opens) || malformed("ask_deliveries") || malformed("closed_delivery_ids")) {
         throw new GatewayToolError("Gateway returned an invalid runner sync result", "local_agent_runner_sync", "GATEWAY_INVALID_TOOL_RESULT");
     }
+    const suspendedJob = parseSuspendedJob(body.suspended_job);
     return {
         opens: body.opens,
         ...(Array.isArray(body.ask_deliveries) ? { askDeliveries: body.ask_deliveries } : {}),
@@ -64,6 +76,7 @@ export function parseRunnerSync(result, runnerId) {
         ...(body.ask_alert === true ? { askAlert: true } : {}),
         ...(body.room_activity_enabled === true ? { roomActivityEnabled: true } : {}),
         ...(Array.isArray(body.fix_consent_grants) ? { fixConsentGrants: parseFixConsentGrants(body.fix_consent_grants) } : {}),
+        ...(suspendedJob ? { suspendedJob } : {}),
         jobAvailable: body.job_available === true,
         push: parsePush(body.push, runnerId),
         syncSeconds: clampSeconds(body.sync_seconds, 15, 120, 30),
@@ -608,6 +621,7 @@ export class McpGatewayClient {
             ...(acknowledged.length > 0 ? { acknowledged_closure_ids: acknowledged } : {}),
             ...(input.guidancePolicyVersion ? { guidance_policy_version: input.guidancePolicyVersion } : {}),
             ...(input.roomActivityV1 ? { room_activity_v1: true } : {}),
+            ...(input.suspendedJob ? { suspended_job: { job_id: input.suspendedJob.jobId, generation: input.suspendedJob.generation } } : {}),
         }, signal);
         return parseRunnerSync(result, this.runnerId);
     }

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

@@ -42,6 +42,8 @@ export function assertLocalFixConsent(value) {
     if (!Array.isArray(modes) || !modes.length || new Set(modes).size !== modes.length || modes.some(m => m !== 'gateway_ci_v1' && m !== 'gateway_publish_v1'))
         throw denied();
 }
+/** One fixed JSON line per repeated publication call; no payload, path or token. */
+const reportRetry = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); };
 /** Serves each job with the registration of the mode frozen in its own Fix scope. */
 function multiModeHost(hosts) {
     const verificationModes = hosts.map(h => { if (h.verificationMode === undefined)
@@ -94,7 +96,7 @@ export async function loadInstalledLocalFixHost(input) {
                     // The scope's own reviewed policy and this measured release make the registration the server CI host checks the job against.
                     const manifest = { verification_mode: mode, project: key, ci_profile: scope.ci_profile, ci_profile_fingerprint: protocolHash(scope.ci_profile), receipt: { ...measured.receipt } };
                     const registration = { ...manifest, review: { status: 'reviewed', fingerprint: protocolHash(manifest) } };
-                    return createServerCiLocalFixHost({ runnerId: input.runnerId, privateRoot, git: config.git, registration, gateway: input.gateway, assertReleaseCurrent, canonicalApprovalId: async (publicationId) => {
+                    return createServerCiLocalFixHost({ runnerId: input.runnerId, privateRoot, git: config.git, registration, gateway: input.gateway, assertReleaseCurrent, report: reportRetry, canonicalApprovalId: async (publicationId) => {
                             let approvals;
                             try {
                                 approvals = await readPrivateJson(path.join(input.stateRoot, 'local-fix-pr-approvals.json'));
@@ -146,7 +148,7 @@ export async function loadInstalledLocalFixHost(input) {
             const privateRoot = path.join(input.stateRoot, 'local-fix-publication'), s = await lstat(privateRoot);
             if (!s.isDirectory() || s.isSymbolicLink() || (s.mode & 0o077) !== 0 || (process.getuid && s.uid !== process.getuid()) || await realpath(privateRoot) !== privateRoot)
                 throw denied();
-            const hosts = registrations.map(registration => createServerCiLocalFixHost({ runnerId: input.runnerId, privateRoot, git: config.git, registration, gateway: input.gateway, assertReleaseCurrent, canonicalApprovalId: async (publicationId) => {
+            const hosts = registrations.map(registration => createServerCiLocalFixHost({ runnerId: input.runnerId, privateRoot, git: config.git, registration, gateway: input.gateway, assertReleaseCurrent, report: reportRetry, canonicalApprovalId: async (publicationId) => {
                     let approvals;
                     try {
                         approvals = await readPrivateJson(path.join(input.stateRoot, 'local-fix-pr-approvals.json'));

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

@@ -14,6 +14,13 @@ 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');
+/** Work Decision b3d7eb22: a failed Gateway publication call is repeated for at most this long; the coordinator heartbeat keeps the lease. */
+export const PUBLICATION_RETRY_WINDOW_MS = 900_000;
+/** 5 s doubling to 130 s, longer than the Gateway's 120-s quiet window, so an absent working branch can be staged again (decision 1bddc563). */
+export const publicationRetryDelay = (failures) => Math.min(5000 * 2 ** (failures - 1), 130_000);
+/** Only the Gateway read of the fence failed; every local check passed, so the call may be repeated. */
+class FenceUnreadable extends Error {
+}
 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));
 /** Gateway decision 8e7fff53: under any directory scope, test infrastructure, boot and dependency files stay as the base has them. */
 const testInfrastructure = (p) => /(^|\/)(phpunit\.xml(\.dist)?|bitbucket-pipelines\.yml|composer\.[^/]+|package(-lock)?\.json|yarn\.lock|pnpm-lock\.yaml)$|^(scripts|app\/common)(\/|$)|(^|\/)(vendor|node_modules)(\/|$)/.test(p);
@@ -82,8 +89,22 @@ export function createServerCiLocalFixHost(options) {
                 throw denied();
             let closed = false, settled = false, stageStarted = false, host, phase = 'validation_report', primary, disposing, finalization, seal;
             const current = async () => { if (closed || !lifecycle.isCurrent() || !lifecycle.isFrozen())
-                throw denied(); await options.assertReleaseCurrent?.(); if (protocolHash(bindingProof((await options.gateway.localPublicationContext(fence)).context)) !== protocolHash(binding) || closed || !lifecycle.isCurrent() || !lifecycle.isFrozen())
+                throw denied(); await options.assertReleaseCurrent?.(); let context; try {
+                context = (await options.gateway.localPublicationContext(fence)).context;
+            }
+            catch {
+                throw new FenceUnreadable();
+            } if (protocolHash(bindingProof(context)) !== protocolHash(binding) || closed || !lifecycle.isCurrent() || !lifecycle.isFrozen())
                 throw denied(); await seal?.assertUnchanged(); };
+            const readable = async () => { try {
+                await current();
+                return true;
+            }
+            catch (error) {
+                if (error instanceof FenceUnreadable)
+                    return false;
+                throw error;
+            } };
             const dispose = () => disposing ??= (host?.dispose() ?? Promise.resolve());
             return { close: async () => { closed = true; if (!finalization || settled) {
                     try {
@@ -198,21 +219,51 @@ export function createServerCiLocalFixHost(options) {
                             if (!security)
                                 throw denied();
                             let result;
+                            const sleep = options.sleep ?? delay, now = options.now ?? Date.now;
+                            // Work Decision b3d7eb22: a string answer names a failed Gateway call, repeated with the same arguments while the
+                            // fence holds. The streak ends at the first accepted answer; a delay that would outlast the window gives up as before.
+                            const retrying = async (attempt) => {
+                                let started;
+                                for (let failures = 1;; failures++) {
+                                    const answer = await attempt();
+                                    if (typeof answer !== 'string')
+                                        return answer;
+                                    started ??= now();
+                                    const wait = publicationRetryDelay(failures);
+                                    if (now() - started + wait > PUBLICATION_RETRY_WINDOW_MS)
+                                        throw new PublicationOutcomeUnknownError();
+                                    try {
+                                        options.report?.({ event: 'local_fix_publication_retry', operation: answer, failures, delay_ms: wait });
+                                    }
+                                    catch { /* diagnostics only */ }
+                                    await sleep(wait);
+                                }
+                            };
                             phase = 'stage';
                             stageStarted = true;
-                            try {
-                                result = (await options.gateway.executeServerCiPublication({ ...fence, operation: 'stage', files, ...(report ? { validationReport: report } : {}), securityReceipt: { ...security }, hostReceipt: { ...registration.receipt } })).result;
-                            }
-                            catch {
-                                throw new PublicationOutcomeUnknownError();
-                            }
-                            const publicationId = result.publication_id;
-                            if (typeof publicationId !== 'string' || !publicationId)
-                                throw new PublicationOutcomeUnknownError();
-                            if (record.publication_id && record.publication_id !== publicationId)
-                                throw new PublicationOutcomeUnknownError();
-                            record.publication_id = publicationId;
-                            await journal.save(key, record);
+                            let stages = 0;
+                            const stageInput = { ...fence, operation: 'stage', files, ...(report ? { validationReport: report } : {}), securityReceipt: { ...security }, hostReceipt: { ...registration.receipt } };
+                            // The same frozen files again: the Gateway reconciles a present branch or stages an absent one again (1bddc563).
+                            result = await retrying(async () => {
+                                if (stages++ > 0 && !await readable())
+                                    return 'fence';
+                                let answer;
+                                try {
+                                    answer = (await options.gateway.executeServerCiPublication(stageInput)).result;
+                                }
+                                catch {
+                                    return 'stage';
+                                }
+                                const id = answer.publication_id;
+                                if (typeof id !== 'string' || !id)
+                                    throw new PublicationOutcomeUnknownError();
+                                if (record.publication_id && record.publication_id !== id)
+                                    throw new PublicationOutcomeUnknownError();
+                                record.publication_id = id;
+                                await journal.save(key, record);
+                                return answer.status === 'publication_unknown' ? 'stage' : answer;
+                            });
+                            const publicationId = String(result.publication_id);
                             const pending = new Set(['staged', 'validating', 'authorized', 'committing', 'committed', 'pushing', 'pushed', 'opening_pr']);
                             for (;;) {
                                 phase = 'result';
@@ -221,7 +272,7 @@ export function createServerCiLocalFixHost(options) {
                                 if (result.status === 'ci_failed')
                                     throw new ServerCiPublicationError(result.ci?.error_code ?? result.failure?.code);
                                 if (result.status === 'completed') {
-                                    await current();
+                                    await retrying(async () => await readable() ? {} : 'fence');
                                     const ci = result.ci;
                                     if (result.verification_mode !== mode || (mode === 'gateway_ci_v1' ? ci?.status !== 'passed' || ci.commit_sha !== result.commit_sha : ci?.status !== 'not_run' || result.verification?.status !== 'unverified') || typeof result.commit_sha !== 'string' || !/^[a-f0-9]{40}$/.test(result.commit_sha) || result.working_branch !== binding.working_branch)
                                         throw new PublicationOutcomeUnknownError();
@@ -230,16 +281,20 @@ export function createServerCiLocalFixHost(options) {
                                 if (result.waiting || !pending.has(String(result.status)))
                                     throw new PublicationOutcomeUnknownError();
                                 phase = 'advance';
-                                await (options.sleep ?? delay)(5000);
-                                await current();
-                                const approval = await options.canonicalApprovalId?.(publicationId);
-                                await current();
-                                try {
-                                    result = (await options.gateway.executeServerCiPublication({ ...fence, operation: 'advance', publicationId, canonicalApprovalId: approval })).result;
-                                }
-                                catch {
-                                    throw new PublicationOutcomeUnknownError();
-                                }
+                                await sleep(5000);
+                                result = await retrying(async () => {
+                                    if (!await readable())
+                                        return 'fence';
+                                    const approval = await options.canonicalApprovalId?.(publicationId);
+                                    if (!await readable())
+                                        return 'fence';
+                                    try {
+                                        return (await options.gateway.executeServerCiPublication({ ...fence, operation: 'advance', publicationId, canonicalApprovalId: approval })).result;
+                                    }
+                                    catch {
+                                        return 'advance';
+                                    }
+                                });
                             }
                         });
                     })().catch(error => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "private": false,
   "license": "UNLICENSED",
   "bin": {