mtech-ai-local-runner 0.1.73 → 0.1.75

package/dist/src/gateway-client.js

@@ -1,3 +1,4 @@
+import { assertClaimedExecutionAttempt, assertBoundExecutionAttempt, CONTINUATION_SCHEMA, CONTINUATION_POLICY } from './verification/continuation-runner-contract.js';
 import { publicationError } from './publication/failure.js';
 import { issueTransportDiagnostic } from './safety/transport-diagnostic.js';
 import { hasP1 } from './verification/p1-execution-host.js';
@@ -17,6 +18,18 @@ export class GatewayToolError extends Error {
         this.code = code;
     }
 }
+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;
@@ -52,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 } : {}),
@@ -60,7 +74,9 @@ export function parseRunnerSync(result, runnerId) {
         ...(typeof body.guidance_policy_version === "string" ? { guidancePolicyVersion: body.guidance_policy_version } : {}),
         ...("claude_release" in body ? { claudeRelease: parseClaudeSyncRelease(body.claude_release) } : {}),
         ...(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),
@@ -116,7 +132,7 @@ export function shadowTaskPackage(contract) {
     const verification = hasP1(payload) ? payload.verification : undefined;
     if (hasP1(payload)) {
         const resolved = resolveRunnerVerification(verification);
-        if (resolved.version === 2 && (nested(payload, 'policy.policy_key') !== REVIEWED_POLICY || nested(payload, 'policy.loop_type') !== REVIEWED_LOOP_TYPE))
+        if (resolved.version !== 1 && (nested(payload, 'policy.policy_key') !== (resolved.version === 3 ? CONTINUATION_POLICY : REVIEWED_POLICY) || nested(payload, 'policy.loop_type') !== REVIEWED_LOOP_TYPE))
             throw Error('P1_CONTRACT_REJECTED');
     }
     const repositories = (payload.repositories ?? []).map((repository) => ({
@@ -315,10 +331,14 @@ export class McpGatewayClient {
         if (!this.checkoutPath) {
             throw new Error("local checkout path is required before creating an execution binding");
         }
-        const useProvidedLease = Boolean(this.initialLeaseToken) && !input.claimNext;
+        const qualified = input.expectedJobId !== undefined || input.expectedAttemptNumber !== undefined;
+        if (qualified && (typeof input.expectedJobId !== 'string' || !input.expectedJobId.trim() || !Number.isSafeInteger(input.expectedAttemptNumber) || input.expectedAttemptNumber < 1 || input.expectedAttemptNumber > 3))
+            throw new GatewayToolError('Qualified next identity is invalid', 'work_loop_next', 'CORRECTION_LINEAGE_MISMATCH');
+        const nextArguments = { work_loop_id: input.workLoopId, ...(qualified ? { expected_job_id: input.expectedJobId, expected_attempt_number: input.expectedAttemptNumber } : {}) };
+        const useProvidedLease = Boolean(this.initialLeaseToken) && !input.claimNext && !qualified;
         const claim = useProvidedLease
             ? await this.callTool("work_loop_show", { work_loop_id: input.workLoopId })
-            : await this.callTool("work_loop_next", { work_loop_id: input.workLoopId });
+            : await this.callTool("work_loop_next", nextArguments);
         const leaseToken = useProvidedLease
             ? this.initialLeaseToken
             : requiredString(claim.lease_token, "lease token");
@@ -505,12 +525,25 @@ export class McpGatewayClient {
         return { leaseExpiresAt: context.leaseExpiresAt };
     }
     async waitForLocalJob(adapterVersions, waitSeconds = 25, jobId) {
-        return this.callTool("local_agent_jobs_wait", {
+        const claim = await this.callTool("local_agent_jobs_wait", {
             runner_id: this.runnerId,
             adapter_versions: adapterVersions,
             ...(jobId ? { job_id: jobId } : {}),
             wait_seconds: Math.max(0, Math.min(30, waitSeconds)),
         });
+        if (['continuation', 'execution_attempt', 'execution_attempt_fingerprint'].some(key => Object.hasOwn(claim, key)))
+            throw new GatewayToolError('Unexpected claimed attempt identity', 'local_agent_jobs_wait', 'GATEWAY_INVALID_TOOL_RESULT');
+        if (claim.status === 'claimed' && claim.task_package && claim.job) {
+            try {
+                assertClaimedExecutionAttempt({ id: claim.job.id, generation: claim.job.generation, workLoopId: claim.job.work_loop_id, launchFingerprint: claim.job.launch_fingerprint, launchGrant: claim.launch_grant ?? '', leaseToken: claim.lease_token ?? '', taskPackage: claim.task_package, executionAttempt: claim.attempt_context, executionAttemptFingerprint: claim.attempt_context_fingerprint });
+            }
+            catch {
+                throw new GatewayToolError('Claimed attempt identity is invalid', 'local_agent_jobs_wait', 'CORRECTION_EXECUTION_UNAVAILABLE');
+            }
+        }
+        else if (claim.attempt_context !== undefined || claim.attempt_context_fingerprint !== undefined)
+            throw new GatewayToolError('Unexpected claimed attempt identity', 'local_agent_jobs_wait', 'GATEWAY_INVALID_TOOL_RESULT');
+        return claim;
     }
     async registerLocalRunner(input) {
         return this.callTool("local_agent_runner_register", {
@@ -587,9 +620,41 @@ export class McpGatewayClient {
             reason: input.reason,
             ...(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);
     }
+    async readRoomActivity(afterRoomId = '', limit = 50, signal) {
+        if ((afterRoomId !== '' && !ROOM_ID.test(afterRoomId)) || !Number.isInteger(limit) || limit < 1 || limit > 100) {
+            throw new GatewayToolError('Invalid Room activity query', 'work_room_read', 'GATEWAY_INVALID_TOOL_RESULT');
+        }
+        const result = await this.callTool('work_room_read', { operation: 'activity', after_room_id: afterRoomId, limit, share_only: true }, signal);
+        const body = result && typeof result === 'object' && !Array.isArray(result) ? result : undefined;
+        if (!body || !Array.isArray(body.rooms) || body.rooms.length > limit
+            || !(body.next_cursor === null || (typeof body.next_cursor === 'string' && ROOM_ID.test(body.next_cursor)))) {
+            throw new GatewayToolError('Invalid Room activity page', 'work_room_read', 'GATEWAY_INVALID_TOOL_RESULT');
+        }
+        const rooms = body.rooms.map(row => {
+            const item = row && typeof row === 'object' && !Array.isArray(row) ? row : {};
+            if (typeof item.room_id !== 'string' || !ROOM_ID.test(item.room_id)
+                || !Number.isSafeInteger(item.unread_count) || item.unread_count < 0
+                || !Number.isSafeInteger(item.latest_message_sequence) || item.latest_message_sequence < 0) {
+                throw new GatewayToolError('Invalid Room activity entry', 'work_room_read', 'GATEWAY_INVALID_TOOL_RESULT');
+            }
+            return { roomId: item.room_id, unreadCount: item.unread_count, latestMessageSequence: item.latest_message_sequence };
+        });
+        let previous = afterRoomId;
+        for (const room of rooms) {
+            if (room.roomId <= previous)
+                throw new GatewayToolError('Room activity order is invalid', 'work_room_read', 'GATEWAY_INVALID_TOOL_RESULT');
+            previous = room.roomId;
+        }
+        if (body.next_cursor !== null && (rooms.length === 0 || body.next_cursor !== previous)) {
+            throw new GatewayToolError('Room activity cursor is invalid', 'work_room_read', 'GATEWAY_INVALID_TOOL_RESULT');
+        }
+        return { rooms, nextCursor: body.next_cursor };
+    }
     async authorizeRunnerChannel(socketId, signal) {
         const result = await this.callTool("local_agent_runner_channel_auth", {
             runner_id: this.runnerId,
@@ -640,6 +705,15 @@ export class McpGatewayClient {
         const bindingId = requiredString(result.binding.id, "binding ID");
         const iterationId = requiredString(result.binding.iteration_id, "iteration ID");
         signal?.throwIfAborted();
+        if (input.claimedJob) {
+            if (input.claimedJob.id !== input.jobId || input.claimedJob.generation !== input.generation || input.claimedJob.workLoopId !== input.workLoopId || input.claimedJob.leaseToken !== input.jobLeaseToken || input.claimedJob.launchGrant !== input.launchGrant || result.work_loop_id !== input.workLoopId)
+                throw Error('CORRECTION_LINEAGE_MISMATCH');
+            assertBoundExecutionAttempt(input.claimedJob, result.bundle, iterationId);
+            if (input.claimedJob.executionAttempt && typeof result.binding_replayed !== 'boolean')
+                throw Error('CORRECTION_BINDING_RECONCILIATION_REQUIRED');
+        }
+        else if (Object.hasOwn(result.bundle, 'attempt_context') || Object.hasOwn(result.bundle, 'attempt_context_fingerprint') || nested(result.bundle, 'contract.verification.schema_version') === CONTINUATION_SCHEMA)
+            throw Error('CORRECTION_LINEAGE_MISMATCH');
         this.context = {
             jobFence: { job_id: input.jobId, generation: input.generation, lease_token: input.jobLeaseToken },
             workLoopId: requiredString(result.work_loop_id, "Work Loop ID"),
@@ -653,7 +727,7 @@ export class McpGatewayClient {
             runtimeAdapterVersion: requiredString(result.binding.runtime_adapter_version, "runtime adapter version"),
         };
         return {
-            bindingId,
+            bindingId, iterationId, ...(input.claimedJob?.executionAttempt ? { bindingReplayed: result.binding_replayed } : {}),
             taskPackage: result.bundle,
             resolvedModelId: requiredString(result.binding.resolved_model_id, "resolved model ID"),
         };

package/dist/src/protocol.js

@@ -1,3 +1,5 @@
+import { validateAttemptContext, attemptContextFingerprint } from './verification/continuation-runner-contract.js';
+import { protocolHash } from './publication/candidate.js';
 export const PROTOCOL_VERSION = "agent-execution-v1";
 export const ROLES = ["planner", "supervisor", "executor", "reviewer"];
 export const EVENT_TYPES = [
@@ -73,3 +75,34 @@ export class TerminalGuard {
         return this.terminalSeen !== null;
     }
 }
+/** Wire-domain/identity check only. Scope, measured command results and grant authority
+ * are verified by their owners; a syntactically valid payload is not completion proof. */
+export function validateAttemptEvidence(value, expected) {
+    const c = validateAttemptContext(expected), fp = attemptContextFingerprint(c);
+    const reject = () => { throw Error('CORRECTION_LINEAGE_MISMATCH'); };
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        reject();
+    const p = value, m = p.changed_paths, receipts = p.receipts;
+    const hex = (v, n) => typeof v === 'string' && new RegExp(`^[a-f0-9]{${n}}$`).test(v);
+    if (!hex(p.candidate_commit_sha, 40) || !hex(p.snapshot_fingerprint, 64) || !m || m.schema_version !== 'runner-changed-paths-v2' || m.digest_domain !== 'p1-changed-paths-v2' || m.attempt_context_fingerprint !== fp || m.base_commit_sha !== c.attempt_base_commit_sha || m.candidate_commit_sha !== p.candidate_commit_sha || !Array.isArray(m.entries) || !m.entries.length || !Array.isArray(receipts) || !receipts.length)
+        reject();
+    const { manifest_sha256, ...unsigned } = m;
+    if (manifest_sha256 !== protocolHash(unsigned))
+        reject();
+    for (const value of receipts) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            reject();
+        const r = value;
+        if (r.schema_version !== 'runner-command-receipt-v2' || r.attempt_context_fingerprint !== fp || r.job_id !== c.job_id || r.generation !== c.generation || r.contract_fingerprint !== c.contract_fingerprint || r.candidate_commit_sha !== p.candidate_commit_sha || r.snapshot_fingerprint !== p.snapshot_fingerprint)
+            reject();
+    }
+}
+/** Versioned host handoff check, distinct from ordinary terminal event transport. */
+export function validateAttemptHandoff(value, expected) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw Error('CORRECTION_LINEAGE_MISMATCH');
+    const h = value, fp = attemptContextFingerprint(expected);
+    if (h.schema_version !== 'gateway-candidate-handoff-v2' || h.attempt_context_fingerprint !== fp || attemptContextFingerprint(h.attempt_context) !== fp)
+        throw Error('CORRECTION_LINEAGE_MISMATCH');
+    validateAttemptEvidence(h, expected);
+}

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 {
@@ -101,8 +122,11 @@ export function createServerCiLocalFixHost(options) {
                         phase = 'current_fence';
                         await current();
                         host = new GitSnapshotHost({ root: input.checkoutPath, privateRoot: root, git: options.git, baseCommitSha: binding.base_commit_sha, workingBranch: binding.working_branch, maxFileBytes: SNAPSHOT_TREE_MAX_BYTES, maxTotalBytes: SNAPSHOT_TREE_MAX_BYTES });
-                        phase = 'snapshot_observe';
-                        const observed = await host.observe();
+                        // materialize captures once, checks live source again after copying, and seals every private byte.
+                        // Use that same observation for limits and upload; a separate observe() repeats two full captures.
+                        phase = 'snapshot_materialize';
+                        seal = await host.materialize();
+                        const observed = structuredClone(seal.observation);
                         phase = 'candidate_limits';
                         let split;
                         if (limits.version === 2) {
@@ -118,10 +142,6 @@ export function createServerCiLocalFixHost(options) {
                             throw publicationError(phase, 'LOCAL_FIX_DIFF_LIMIT_REJECTED');
                         if (!observed.changed_files.length || observed.changed_files.length > limits.max_changed_files)
                             throw publicationError(phase, 'LOCAL_FIX_FILE_COUNT_REJECTED');
-                        phase = 'snapshot_materialize';
-                        seal = await host.materialize();
-                        if (protocolHash(observed) !== protocolHash(seal.observation))
-                            throw denied();
                         // The v1 wire represents ordinary text bytes only. Refuse any change whose
                         // executable/type metadata would be lost by the provider's regular-file write.
                         phase = 'delta_format';
@@ -199,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';
@@ -222,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();
@@ -231,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/dist/src/rooms/activity.js

@@ -0,0 +1,84 @@
+import { RoomActivityStore } from './store.js';
+export const ROOM_CHAT_LINE = 'AI Gateway notice: Tell the person new Work Room activity is available. Read the Room only if they ask; do not reply automatically.';
+/** One actor-owned projection. Scans serialize so a signal and periodic sync cannot race the watermark file. */
+export class RoomActivityRuntime {
+    deps;
+    store;
+    queue = Promise.resolve();
+    constructor(deps) {
+        this.deps = deps;
+        this.store = new RoomActivityStore(deps.stateRoot);
+    }
+    exclusive(work) {
+        const result = this.queue.then(work);
+        this.queue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async handleSync(enabled) {
+        await this.exclusive(async () => {
+            const state = await this.store.load();
+            if (!enabled) {
+                if (state.pendingChat.length || state.pendingOs.length) {
+                    state.pendingChat = [];
+                    state.pendingOs = [];
+                    await this.store.save(state);
+                }
+                return;
+            }
+            const rows = [];
+            const cursors = new Set();
+            let cursor = state.scanCursor ?? '';
+            let complete = false;
+            for (let page = 0; page < 20; page++) {
+                if (cursors.has(cursor))
+                    throw new Error('ROOM_ACTIVITY_CURSOR_LOOP');
+                cursors.add(cursor);
+                const result = await this.deps.read(cursor, 50);
+                rows.push(...result.rooms);
+                if (result.nextCursor === null) {
+                    cursor = '';
+                    complete = true;
+                    break;
+                }
+                cursor = result.nextCursor;
+            }
+            const visible = new Set([...(state.scanVisible ?? []), ...rows.map(row => row.roomId)]);
+            const next = {
+                version: 1, seen: complete ? {} : { ...state.seen },
+                pendingOs: complete ? state.pendingOs.filter(id => visible.has(id)) : [...state.pendingOs],
+                pendingChat: complete ? state.pendingChat.filter(id => visible.has(id)) : [...state.pendingChat],
+                ...(complete ? {} : { scanCursor: cursor, scanVisible: [...visible] }),
+            };
+            if (complete) {
+                for (const id of visible)
+                    if (id in state.seen)
+                        next.seen[id] = state.seen[id];
+            }
+            for (const row of rows) {
+                const previous = state.seen[row.roomId] ?? 0;
+                next.seen[row.roomId] = Math.max(previous, row.latestMessageSequence);
+                if (row.unreadCount > 0 && row.latestMessageSequence > previous) {
+                    if (!next.pendingOs.includes(row.roomId))
+                        next.pendingOs.push(row.roomId);
+                    if (!next.pendingChat.includes(row.roomId))
+                        next.pendingChat.push(row.roomId);
+                }
+            }
+            await this.store.save(next);
+            if (next.pendingOs.length && await this.deps.notify()) {
+                next.pendingOs = [];
+                await this.store.save(next);
+            }
+        });
+    }
+    async claimNotice() {
+        return this.exclusive(async () => {
+            const state = await this.store.load();
+            if (!state.pendingChat.length)
+                return null;
+            state.pendingChat = [];
+            await this.store.save(state);
+            return ROOM_CHAT_LINE;
+        });
+    }
+}

package/dist/src/rooms/notifier.js

@@ -0,0 +1,21 @@
+import { execFile } from 'node:child_process';
+export const ROOM_OS_LINE = 'AI Gateway: new Work Room activity. Open your AI chat to review it.';
+const SCRIPT = ['on run argv', 'display notification (item 1 of argv) with title "AI Gateway"', 'end run'];
+export function createRoomNotifier(deps = {}) {
+    const run = deps.run ?? ((file, args) => new Promise((resolve, reject) => {
+        execFile(file, args, { timeout: 3000, killSignal: 'SIGKILL' }, error => error ? reject(error) : resolve());
+    }));
+    return async () => {
+        if ((deps.platform ?? process.platform) !== 'darwin')
+            return false;
+        try {
+            await run('/usr/bin/osascript', [...SCRIPT.flatMap(line => ['-e', line]), ROOM_OS_LINE]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/** Generic macOS notice. No Room metadata enters the command line or error log. */
+export const notifyRoomActivity = createRoomNotifier();

package/dist/src/rooms/store.js

@@ -0,0 +1,56 @@
+import { promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+const EMPTY = () => ({ version: 1, seen: {}, pendingOs: [], pendingChat: [] });
+const ROOM_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export class RoomActivityStore {
+    stateRoot;
+    path;
+    constructor(stateRoot) {
+        this.stateRoot = stateRoot;
+        this.path = join(stateRoot, 'room-activity.json');
+    }
+    async load() {
+        let content;
+        try {
+            content = await fs.readFile(this.path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return EMPTY();
+            throw error;
+        }
+        const raw = JSON.parse(content);
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error('ROOM_ACTIVITY_STATE_INVALID');
+        const state = raw;
+        if (state.version !== 1 || !state.seen || typeof state.seen !== 'object' || Array.isArray(state.seen)
+            || !Array.isArray(state.pendingOs) || !Array.isArray(state.pendingChat))
+            throw new Error('ROOM_ACTIVITY_STATE_INVALID');
+        for (const [id, sequence] of Object.entries(state.seen)) {
+            if (!ROOM_ID.test(id) || !Number.isSafeInteger(sequence) || sequence < 0)
+                throw new Error('ROOM_ACTIVITY_STATE_INVALID');
+        }
+        for (const id of [...state.pendingOs, ...state.pendingChat]) {
+            if (typeof id !== 'string' || !ROOM_ID.test(id) || !(id in state.seen))
+                throw new Error('ROOM_ACTIVITY_STATE_INVALID');
+        }
+        if (state.scanCursor !== undefined && (typeof state.scanCursor !== 'string' || !ROOM_ID.test(state.scanCursor)))
+            throw new Error('ROOM_ACTIVITY_STATE_INVALID');
+        if (state.scanVisible !== undefined && (!Array.isArray(state.scanVisible)
+            || state.scanVisible.some(id => typeof id !== 'string' || !ROOM_ID.test(id))))
+            throw new Error('ROOM_ACTIVITY_STATE_INVALID');
+        return state;
+    }
+    async save(state) {
+        await fs.mkdir(this.stateRoot, { recursive: true, mode: 0o700 });
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        try {
+            await fs.writeFile(temp, JSON.stringify(state), { mode: 0o600, flag: 'wx' });
+            await fs.rename(temp, this.path);
+        }
+        finally {
+            await fs.rm(temp, { force: true });
+        }
+    }
+}

package/dist/src/safety/claude-managed-scope.js

@@ -1,8 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { lstat, readdir } from 'node:fs/promises';
-import { createPolicyInventoryClient, verifyPolicyObserver } from './policy-inventory-client.js';
-import { CLAUDE_MANAGED_PREFERENCE_DOMAIN, CLAUDE_MANAGED_SETTINGS_DIRECTORY, CLAUDE_MANAGED_SETTINGS_FILES, CLAUDE_POLICY_OBSERVER, claudeCanonicalSha256 } from './claude-release.js';
+import { CLAUDE_MANAGED_PREFERENCE_DOMAIN, CLAUDE_MANAGED_SETTINGS_DIRECTORY, CLAUDE_MANAGED_SETTINGS_FILES, claudeCanonicalSha256 } from './claude-release.js';
 const unverified = () => Error('CLAUDE_MANAGED_SCOPE_UNVERIFIED');
 /** Claude managed sources the Runner checks on macOS (gate managed_scope_exclusion, scope unmanaged_personal_only). */
 export function claudeManagedPaths(user, root = '/') {
@@ -50,38 +49,27 @@ export async function assertClaudeManagedPathsAbsent(user, root = '/') {
     if (entries.length !== 0)
         throw unverified();
 }
-/** Compiled defaults: the pinned installed observer (single-use clients) and the real managed locations. */
+/** Compiled defaults: the real managed locations. */
 export function claudeManagedScopeDeps(root = '/') {
-    return {
-        checkReady: async () => { verifyPolicyObserver(CLAUDE_POLICY_OBSERVER); await createPolicyInventoryClient(CLAUDE_POLICY_OBSERVER).checkReady(); },
-        collect: () => createPolicyInventoryClient(CLAUDE_POLICY_OBSERVER).collectOnce(),
-        managedPathsAbsent: () => assertClaudeManagedPathsAbsent(os.userInfo().username, root),
-    };
+    return { managedPathsAbsent: () => assertClaudeManagedPathsAbsent(os.userInfo().username, root) };
 }
 export async function claudeManagedScopeReady(deps) {
     try {
-        await deps.checkReady();
         await deps.managedPathsAbsent();
     }
     catch {
         throw unverified();
     }
 }
-/** Per-job managed scope: no configuration profile at all for machine and user (complete, empty, at most 60 s old),
- * plus absent Claude managed files. Managed, partial, unknown or stale input blocks. */
+/** Per-job managed scope: absent Claude managed files and managed preferences. Present or unreadable input blocks. */
 export async function collectClaudeManagedScope(deps) {
     try {
-        const value = await deps.collect(), now = (deps.now ?? Date.now)();
-        const r = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-        const observedAt = r.observedAt;
-        if (r.complete !== true || r.empty !== true || r.scope !== 'machine_and_current_user' || typeof observedAt !== 'number' || !Number.isSafeInteger(observedAt)
-            || observedAt > now || now - observedAt > 60_000 || typeof r.inventoryFingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(r.inventoryFingerprint))
-            throw unverified();
         await deps.managedPathsAbsent();
-        const bound = { observer_sha256: CLAUDE_POLICY_OBSERVER.sha256, inventory_fingerprint: r.inventoryFingerprint, managed_paths: 'absent' };
-        return Object.freeze({ observerSha256: CLAUDE_POLICY_OBSERVER.sha256, inventoryFingerprint: r.inventoryFingerprint, fingerprint: claudeCanonicalSha256(bound) });
     }
     catch {
         throw unverified();
     }
+    const bound = { basis: 'managed_paths_as_user', managed_paths: 'absent', directory: CLAUDE_MANAGED_SETTINGS_DIRECTORY,
+        files: [...CLAUDE_MANAGED_SETTINGS_FILES], preference_domain: CLAUDE_MANAGED_PREFERENCE_DOMAIN };
+    return Object.freeze({ fingerprint: claudeCanonicalSha256(bound) });
 }

package/dist/src/safety/claude-release.js

@@ -22,8 +22,6 @@ export const CLAUDE_TEAM_ID = 'Q6L2SF6YDW';
 export const CLAUDE_SIGNING_IDENTIFIER = 'com.anthropic.claude-code';
 /** Official native-build distribution. Never taken from the Gateway, a task, config or env. */
 export const CLAUDE_DOWNLOAD_BASE = 'https://downloads.claude.ai/claude-code-releases';
-/** The installed privileged observer; the same reviewed binary the Codex daemon release pins. */
-export const CLAUDE_POLICY_OBSERVER = Object.freeze({ protocol: 'policy-inventory-v1', sha256: '2a07812cd47782826a359b749096b681a6ee49e91f990d48abdc60f2d46e4c9c' });
 /** macOS managed sources (docs/superpowers/specs/2026-10-16-cli-managed-auth-lab-scope.json) and the MDM preference domain. */
 export const CLAUDE_MANAGED_SETTINGS_DIRECTORY = '/Library/Application Support/ClaudeCode';
 export const CLAUDE_MANAGED_SETTINGS_FILES = Object.freeze([`${CLAUDE_MANAGED_SETTINGS_DIRECTORY}/managed-settings.json`, `${CLAUDE_MANAGED_SETTINGS_DIRECTORY}/managed-mcp.json`]);