agents-relay 2.0.66 → 2.0.68

package/dist/relayd.js

@@ -6,15 +6,17 @@ import { join } from 'node:path';
 import { ChatGptAdapter, CodexAdapter, ensureChatGptBrowserWorkspace } from './adapters.js';
 import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
 import { serveDashboard } from './dashboard.js';
-import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
+import { RepositoryWorkerPool } from './pool.js';
 import { Reconciler } from './reconciler.js';
-import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPullRequestSnapshotGraphql, withGitHubRequestContext } from './store.js';
-import { ProjectedDurableStore } from './projected-store.js';
+import { dashboardManagedJobs, GitHubStore, InMemoryStore } from './store.js';
+import { LocalAuthorityDurableStore } from './local-authority-store.js';
 import { discoverLocalRelayStoreSnapshots, relayStorePath, SQLiteRelayStore } from './relay-store.js';
-import { githubAuthContext } from './github-auth.js';
+import { createJobIdRegistryResolver } from './local-job-registry.js';
+import { GhApiClient } from './github-client.js';
+import { DisabledGitHubClient, noGitHubMode } from './no-github.js';
+import { basename } from 'node:path';
 import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
 import { eventBusResolutionMessage, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, resolveEventBus } from './cli-support.js';
-import { eventFor } from './events.js';
 import { applyJobActivateAction } from './job-actions.js';
 import { applyOrchestratorStartAction, applyOrchestratorCompleteAction } from './task-actions.js';
 import { managedTaskUpdateHandler } from './task-update.js';
@@ -56,7 +58,7 @@ export function mergeOperationalInventory(current, discovered) {
 const PR_REFRESH_COALESCE_MS = 1000;
 export const SCHEDULE_HEARTBEAT_MS = 600_000;
 export function dueScheduledOverviews(overviews, now = new Date()) {
-    return overviews.filter(item => item.githubState === 'OPEN' && item.job.executionMode === 'autonomous' && item.job.schedule && Date.parse(item.job.schedule.nextRunAt) <= now.getTime());
+    return overviews.filter(item => item.job.state === 'ACTIVE' && item.job.executionMode === 'autonomous' && item.job.schedule && Date.parse(item.job.schedule.nextRunAt) <= now.getTime());
 }
 export function shouldCoalescePullRequestRefresh(completedAt, now = Date.now(), force = false) {
     return !force && completedAt !== null && now >= completedAt && now - completedAt < PR_REFRESH_COALESCE_MS;
@@ -67,6 +69,7 @@ Usage:
   npx agents-relayd [options]
 
 Options:
+  --no-github             Local-only mode: no GitHub auth, transport, PR, merge, or fetch
   --repo OWNER/REPO       Watch one repository
   --workspace PATH        Discover repositories below PATH (default: ~/Workspace)
   --port PORT             Dashboard port (default: 8787)
@@ -117,7 +120,7 @@ export function recoveryScanRepositories(repositories, cached, dormantProbeIndex
     const dormant = [];
     for (const repository of repositories) {
         const values = byRepository.get(repository);
-        if (!values || values.length === 0 || values.some(item => item.githubState === 'OPEN' && !['COMPLETED', 'CANCELLED'].includes(item.job.state)))
+        if (!values || values.length === 0 || values.some(item => !['COMPLETED', 'CANCELLED'].includes(item.job.state)))
             activeOrUnknown.push(repository);
         else
             dormant.push(repository);
@@ -145,22 +148,30 @@ export async function runDaemon(argv) {
     catch (error) {
         process.stderr.write(`Browser Workspace bootstrap skipped: ${errorMessage(error)}\n`);
     }
+    const noGitHub = noGitHubMode(argv);
+    if (noGitHub)
+        process.env.AGENTS_RELAY_NO_GITHUB = '1';
     const normalized = normalizeDaemonArguments(argv);
     if (normalized.pullRequest && normalized.jobId) {
         await startService([...argv]);
         return;
     }
-    const auth = await githubAuthContext(argv);
-    const client = auth.client;
-    const trusted = auth.trustedAuthors;
+    // Local authority starts without GitHub authentication. External audit transport
+    // is optional and may initialize independently after the daemon is online.
+    const client = noGitHub ? new DisabledGitHubClient() : new GhApiClient();
+    const trusted = new Set();
     const concurrency = Number(value(argv, '--concurrency', '4'));
     const eventResolution = await resolveEventBus([...argv]);
     const bus = eventResolution.bus;
     process.stderr.write(`${eventBusResolutionMessage(eventResolution)}\n`);
-    const workspaceRoot = normalized.workspaceRoot ?? defaultWorkspaceRoot();
-    const discoveredRepositories = normalized.repository ? [] : await discoverWorkspaceRepositories(workspaceRoot);
-    const repositories = normalized.repository ? [normalized.repository] : discoveredRepositories.map(item => item.repository);
+    const workspaceRoot = noGitHub ? (value(argv, '--project-path') || value(argv, '--workspace') || process.cwd())
+        : normalized.workspaceRoot ?? defaultWorkspaceRoot();
+    const discoveredRepositories = normalized.repository || noGitHub ? [] : await discoverWorkspaceRepositories(workspaceRoot).catch(() => []);
+    const repositories = noGitHub && !normalized.repository ? [`local/${basename(workspaceRoot)}`] : normalized.repository ? [normalized.repository] : discoveredRepositories.map(item => item.repository);
     const repositoryPaths = new Map(discoveredRepositories.map(item => [item.repository, item.path]));
+    if (noGitHub)
+        for (const repo of repositories)
+            repositoryPaths.set(repo, value(argv, '--project-path') || workspaceRoot);
     const explicitProjectPath = value(argv, '--project-path');
     const usageRegistry = codexAndZaiUsageRegistry();
     const decisionAuditStore = new JsonlDecisionAuditStore(process.env.AGENTS_RELAY_DECISION_AUDIT_PATH ?? join(homedir(), '.agents-relay', 'decision-audit.jsonl'));
@@ -177,97 +188,62 @@ export async function runDaemon(argv) {
             relayStores.set(key, relay);
         }
         const github = new GitHubStore(client, repository, prNumber, trusted, seed);
-        const projected = new ProjectedDurableStore(relay, github, seed ?? null, (relatedRepository, relatedPrNumber) => runtimeStore(relatedRepository, relatedPrNumber), conflict => {
-            process.stderr.write(`projection conflict for ${repository}#${prNumber}: ${conflict.message} (fields: ${conflict.data.divergingFields.join(', ') || 'unknown'}; repair with agents-relay projection resolve)\n`);
-            if (bus) {
-                const jobId = conflict.data.jobId || conflictJobId(repository, prNumber);
-                void Promise.resolve().then(() => bus.publish(eventFor(jobId, 'projection', null, 'projection.conflict', 'blocked', conflict.message, 'orchestrator', { ...conflict.data, repository, prNumber }))).catch(() => undefined);
-            }
-        });
-        projectionWriters.set(key, projected.projection);
+        const projected = new LocalAuthorityDurableStore(relay, github, (relatedRepository, relatedPrNumber) => runtimeStore(relatedRepository, relatedPrNumber), noGitHub);
+        // SQLite PR facts are written through awaited webhook/action handlers; never seed detached remote snapshots.
+        if (!noGitHub)
+            projectionWriters.set(key, projected.projection);
         return projected;
     };
-    if (repositories.length === 0)
-        throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
-    const localSnapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
-    const knownRepositories = new Set(repositories);
-    cachedOverviews = dashboardManagedJobs(localSnapshots.flatMap(snapshot => {
-        if (!snapshot.facts)
-            return [];
-        return snapshot.jobs.filter(job => knownRepositories.has(job.repository)).map(job => ({
-            job, githubState: snapshot.facts.state, draft: false, mergedAt: null, closedAt: null, publication: null,
-        }));
-    }));
-    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(argv), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
-    const refreshAll = async (full = false) => {
-        if (client.rateLimitStatus().limited)
-            return cachedOverviews;
-        const scanRepositories = full ? repositories : recoveryScanRepositories(repositories, cachedOverviews, dormantProbeIndex++);
-        if (scanRepositories.length === 0)
-            return cachedOverviews;
-        try {
-            githubReadPaths.workspaceScans += 1;
-            const refreshed = await withGitHubRequestContext(client, 'relayd.workspace-refresh', () => aggregateManagedGitHubJobs(client, scanRepositories, trusted));
-            const merged = mergeOperationalInventory(cachedOverviews, refreshed);
-            cachedOverviews = dashboardManagedJobs(await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber)));
-            return cachedOverviews;
-        }
-        catch (error) {
-            observability().record({ stage: 'daemon', event: 'daemon.refresh_failed', level: 'warn', outcome: 'failed', message: `Workspace job refresh unavailable: ${errorMessage(error)}`, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
-            return cachedOverviews;
+    // SQLite inventory, not GitHub discovery, defines which repositories exist.
+    const existingInventory = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+    for (const snapshot of existingInventory)
+        for (const job of snapshot.jobs) {
+            if (!repositories.includes(job.repository))
+                repositories.push(job.repository);
         }
+    if (repositories.length === 0)
+        repositories.push('local/' + basename(workspaceRoot));
+    const inventoryFromLocal = async () => {
+        const snapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+        const known = new Set(repositories);
+        const entries = snapshots.flatMap(snapshot => snapshot.jobs.filter(job => known.has(job.repository)).map(job => ({
+            job, githubState: snapshot.facts?.state ?? 'UNKNOWN',
+            draft: false, mergedAt: null, closedAt: null, publication: snapshot.publications[job.id]?.latest ?? null, publicationFailure: snapshot.publications[job.id]?.failure ?? null,
+        })));
+        const counts = new Map();
+        for (const item of entries)
+            if (!['COMPLETED', 'CANCELLED'].includes(item.job.state))
+                counts.set(item.job.id, (counts.get(item.job.id) ?? 0) + 1);
+        // Hide obsolete terminal snapshots only when one live authoritative Job exists.
+        // Multiple live copies remain visible for diagnosis but cannot be mutated.
+        return dashboardManagedJobs(entries.filter(item => !['COMPLETED', 'CANCELLED'].includes(item.job.state) || counts.get(item.job.id) !== 1));
     };
-    const overviews = async (forceRefresh = false, _trigger = 'internal.unknown') => {
-        if (forceRefresh)
-            return refreshAll(true);
-        cachedOverviews = await overlayOperationalOverviews(cachedOverviews, (repository, prNumber) => runtimeStore(repository, prNumber));
+    cachedOverviews = await inventoryFromLocal();
+    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { noGitHub, owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(argv), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
+    const refreshAll = async (_full = false) => {
+        cachedOverviews = await inventoryFromLocal();
         return cachedOverviews;
     };
-    const pullRequestRefreshFlights = new Map();
-    const pullRequestRefreshCache = new Map();
-    const incrementTrigger = (counts, trigger) => { counts[trigger] = (counts[trigger] ?? 0) + 1; };
-    const refreshPullRequestSnapshot = async (repository, prNumber, trigger = 'internal', options = {}) => {
-        if (client.rateLimitStatus().limited)
-            return { overviews: cachedOverviews.filter(item => item.job.repository === repository && item.job.prNumber === prNumber), seed: { prNode: {}, comments: null } };
-        const key = `${repository}#${prNumber}`;
-        incrementTrigger(githubReadPaths.prRefreshesByTrigger, trigger);
-        const existing = pullRequestRefreshFlights.get(key);
-        if (existing) {
-            githubReadPaths.prRefreshCoalesced += 1;
-            incrementTrigger(githubReadPaths.prRefreshCoalescedByTrigger, trigger);
-            return existing;
-        }
-        const cached = pullRequestRefreshCache.get(key);
-        if (cached && shouldCoalescePullRequestRefresh(cached.completedAt, Date.now(), options.force === true)) {
-            githubReadPaths.prRefreshCoalesced += 1;
-            incrementTrigger(githubReadPaths.prRefreshCoalescedByTrigger, trigger);
-            return cached.snapshot;
-        }
-        const flight = (async () => {
-            githubReadPaths.prRefreshes += 1;
-            const snapshot = await withGitHubRequestContext(client, `relayd.pr-refresh:${trigger}`, () => loadManagedGitHubPullRequestSnapshotGraphql(client, repository, prNumber, trusted));
-            const operational = await overlayOperationalOverviews(snapshot.overviews, (repo, pr) => runtimeStore(repo, pr, repo === repository && pr === prNumber ? snapshot.seed : null));
-            cachedOverviews = cachedOverviews.filter(item => item.job.repository !== repository || item.job.prNumber !== prNumber);
-            cachedOverviews.push(...operational);
-            cachedOverviews = dashboardManagedJobs(cachedOverviews);
-            const operationalSnapshot = { ...snapshot, overviews: operational };
-            pullRequestRefreshCache.set(key, { snapshot: operationalSnapshot, completedAt: Date.now() });
-            return operationalSnapshot;
-        })();
-        pullRequestRefreshFlights.set(key, flight);
-        try {
-            return await flight;
-        }
-        finally {
-            if (pullRequestRefreshFlights.get(key) === flight)
-                pullRequestRefreshFlights.delete(key);
-        }
+    const overviews = async (_forceRefresh = false, _trigger = 'internal.unknown') => refreshAll();
+    const refreshPullRequestSnapshot = async (repository, prNumber, _trigger = 'internal', _options = {}) => {
+        const inventory = await refreshAll();
+        return {
+            overviews: inventory.filter(item => item.job.repository === repository && item.job.prNumber === prNumber),
+            seed: { prNode: {}, comments: null },
+        };
     };
     const refreshPullRequest = async (repository, prNumber, trigger, options) => (await refreshPullRequestSnapshot(repository, prNumber, trigger, options)).overviews;
-    const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler, () => client.rateLimitStatus().limited, (repository, prNumber, trigger) => refreshPullRequestSnapshot(repository, prNumber, trigger), (repository, prNumber, seed) => runtimeStore(repository, prNumber, seed));
+    const localJobBinding = createJobIdRegistryResolver(join(homedir(), '.agents-relay', 'stores'), relayStores);
+    const requireLocalJobBinding = async (jobId) => {
+        const binding = await localJobBinding(jobId);
+        if (!binding)
+            throw new Error('Local Job ' + jobId + ' not found or ambiguous in SQLite registry');
+        return binding;
+    };
+    const pool = new RepositoryWorkerPool(concurrency, makeReconciler, inventoryFromLocal, localJobBinding);
     const initial = cachedOverviews;
     const fallback = initial[0]?.job;
-    const dashboardStore = fallback ? runtimeStore(fallback.repository, fallback.prNumber) : new InMemoryStore();
+    const dashboardStore = fallback ? (await requireLocalJobBinding(fallback.id)).store : new InMemoryStore();
     const dashboardOverview = (jobId, target) => cachedOverviews.find(item => item.job.id === jobId
         && (!target?.repository || item.job.repository === target.repository)
         && (!target?.prNumber || item.job.prNumber === target.prNumber));
@@ -275,9 +251,9 @@ export async function runDaemon(argv) {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         if (action === 'reconcile') {
-            await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId);
+            await pool.reconcileLocalJob(jobId, 'control.job.reconcile');
             return await store.load(jobId);
         }
         return await dashboardJobAction(store, makeReconciler(store, concurrency), action)(jobId);
@@ -286,9 +262,9 @@ export async function runDaemon(argv) {
         const overview = dashboardOverview(jobId, target);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         const result = await dashboardJobSetState(store)(jobId, state);
-        await refreshPullRequest(overview.job.repository, overview.job.prNumber, 'dashboard.job-state', { force: true });
+        await refreshAll();
         return result;
     };
     const workspaceTaskCreate = async (jobId, task) => {
@@ -297,7 +273,7 @@ export async function runDaemon(argv) {
             throw new Error(`Managed job ${jobId} not found`);
         if (task.jobId !== jobId)
             throw new Error(`Task ${task.id} belongs to ${task.jobId}, not ${jobId}`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         const job = await store.load(jobId);
         if (['COMPLETED', 'CANCELLED'].includes(job.state))
             throw new Error(`Cannot create task on terminal job ${job.id} (${job.state})`);
@@ -307,14 +283,14 @@ export async function runDaemon(argv) {
             await applyJobActivateAction(refreshed);
             await store.saveJob(refreshed);
         }
-        await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId, 'control.task.create');
+        await pool.reconcileLocalJob(jobId, 'control.task.create');
         return await store.load(jobId);
     };
     const workspaceTaskStart = async (jobId, taskId) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         const job = await store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
         if (!task)
@@ -322,14 +298,14 @@ export async function runDaemon(argv) {
         await applyOrchestratorStartAction(task);
         await store.saveTask(task);
         await publishOrchestratorTaskStarted(bus, job, task);
-        await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId, 'control.task.start');
+        await pool.reconcileLocalJob(jobId, 'control.task.start');
         return await store.load(jobId);
     };
     const workspaceTaskComplete = async (jobId, taskId, summary) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         const job = await store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
         if (!task)
@@ -337,27 +313,27 @@ export async function runDaemon(argv) {
         await applyOrchestratorCompleteAction(task, summary);
         await store.saveTask(task);
         await publishOrchestratorTaskCompletion(bus, job, task, summary);
-        await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId, 'control.task.complete');
+        await pool.reconcileLocalJob(jobId, 'control.task.complete');
         return await store.load(jobId);
     };
     const workspaceTaskAction = (action) => async (jobId, taskId) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         return await dashboardTaskAction(store, makeReconciler(store, concurrency), action)(jobId, taskId);
     };
     const workspaceTaskSetState = async (jobId, taskId, state, target) => {
         const overview = dashboardOverview(jobId, target);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const store = (await requireLocalJobBinding(jobId)).store;
         const result = await dashboardTaskSetState(store)(jobId, taskId, state);
-        await refreshPullRequest(overview.job.repository, overview.job.prNumber, 'dashboard.task-state', { force: true });
+        await refreshAll();
         return result;
     };
     const secretFile = value(argv, '--github-webhook-secret-file');
-    const secret = value(argv, '--github-webhook-secret') || process.env.AGENTS_RELAY_GITHUB_WEBHOOK_SECRET || (secretFile ? (await readFile(secretFile, 'utf8')).trim() : '');
+    const secret = noGitHub ? '' : value(argv, '--github-webhook-secret') || process.env.AGENTS_RELAY_GITHUB_WEBHOOK_SECRET || (secretFile ? (await readFile(secretFile, 'utf8')).trim() : '');
     const webhook = secret ? {
         secret,
         repositories: new Set(repositories),
@@ -366,12 +342,25 @@ export async function runDaemon(argv) {
             if (targets.length === 0)
                 return;
             for (const target of targets) {
-                const store = runtimeStore(event.repository, event.pullRequest);
+                const binding = await requireLocalJobBinding(target.job.id);
+                const store = binding.store;
                 if (event.pullRequestFacts && store.applyPullRequestFacts) {
-                    await store.applyPullRequestFacts({ ...event.pullRequestFacts, observedAt: new Date().toISOString() });
-                    target.githubState = event.pullRequestFacts.state;
+                    await store.applyPullRequestFacts({ ...event.pullRequestFacts,
+                        observedAt: event.pullRequestFacts.observedAt ?? new Date().toISOString() });
+                    target.githubState = await store.pullRequestState?.() ?? target.githubState;
+                }
+                if (event.publication || event.publishFailure) {
+                    const relay = binding.relay;
+                    try {
+                        const inserted = await relay.recordPublication(target.job.id, event.deliveryId, event.publication, event.publishFailure ?? null, event.publicationObservedAt);
+                        // Replayed webhook deliveries may retry EventBus delivery; SQLite state remains idempotent.
+                        const state = await relay.loadPublication(target.job.id);
+                        target.publication = state?.latest ?? null;
+                        target.publicationFailure = state?.failure ?? null;
+                    }
+                    finally { /* The SQLite registry owns the shared connection. */ }
                 }
-                await pool.webhookWake(bus, target.job, event);
+                // GitHub is an audit input only: no workflow or reconcile wake.
             }
             cachedOverviews = dashboardManagedJobs(cachedOverviews);
         }
@@ -384,14 +373,12 @@ export async function runDaemon(argv) {
         }
         if (!cached)
             return null;
-        const cachedJob = () => ({ ...cached.job, githubState: cached.githubState, runtimeStatus: deriveJobRuntimeStatus(cached.job, cached.githubState), mergedAt: cached.mergedAt, closedAt: cached.closedAt, draft: cached.draft, publication: cached.publication });
-        if (client.rateLimitStatus().limited)
-            return cachedJob();
+        const cachedJob = () => ({ ...cached.job, githubState: cached.githubState, runtimeStatus: deriveJobRuntimeStatus(cached.job, cached.githubState), mergedAt: cached.mergedAt, closedAt: cached.closedAt, draft: cached.draft, publication: cached.publication, publicationFailure: cached.publicationFailure });
         try {
             const refreshed = (await refreshPullRequest(cached.job.repository, cached.job.prNumber, 'dashboard.selected-job', { force: true })).find(item => item.job.id === jobId);
             if (!refreshed)
                 return null;
-            return { ...refreshed.job, githubState: refreshed.githubState, runtimeStatus: deriveJobRuntimeStatus(refreshed.job, refreshed.githubState), mergedAt: refreshed.mergedAt, closedAt: refreshed.closedAt, draft: refreshed.draft, publication: refreshed.publication };
+            return { ...refreshed.job, githubState: refreshed.githubState, runtimeStatus: deriveJobRuntimeStatus(refreshed.job, refreshed.githubState), mergedAt: refreshed.mergedAt, closedAt: refreshed.closedAt, draft: refreshed.draft, publication: refreshed.publication, publicationFailure: refreshed.publicationFailure };
         }
         catch (error) {
             observability().record({ stage: 'daemon', event: 'daemon.refresh_failed', level: 'warn', outcome: 'failed', message: `Selected job refresh unavailable: ${errorMessage(error)}`, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
@@ -399,14 +386,16 @@ export async function runDaemon(argv) {
         }
     };
     const stopWatch = bus ? await pool.watch(bus) : async () => { };
-    const server = serveDashboard(dashboardStore, Number(value(argv, '--port', String(SERVICE_DEFAULTS.port))), bus, Number(value(argv, '--refresh-ms', String(SERVICE_DEFAULTS.dashboardRefreshMs))), fallback?.id, usageRegistry, overviews, webhook, () => ({ ...client.rateLimitStatus(), readPaths: { ...githubReadPaths } }), () => client.rateLimitSnapshot(), exactJob, {
+    const server = serveDashboard(dashboardStore, Number(value(argv, '--port', String(SERVICE_DEFAULTS.port))), bus, Number(value(argv, '--refresh-ms', String(SERVICE_DEFAULTS.dashboardRefreshMs))), fallback?.id, usageRegistry, overviews, webhook, () => ({ ...client.rateLimitStatus(), readPaths: { ...githubReadPaths } }), noGitHub ? undefined : () => client.rateLimitSnapshot(), exactJob, {
         start: workspaceJobAction('start'),
         reconcile: workspaceJobAction('reconcile'),
         cancel: workspaceJobAction('cancel'),
         jobSetState: workspaceJobSetState,
         taskCreate: workspaceTaskCreate,
-        taskUpdate: managedTaskUpdateHandler(jobId => { const row = cachedOverviews.find(item => item.job.id === jobId); if (!row)
-            throw new Error('Job not found'); return { store: runtimeStore(row.job.repository, row.job.prNumber), repository: row.job.repository, prNumber: row.job.prNumber }; }, (repository, prNumber, jobId) => pool.reconcileTarget(repository, prNumber, jobId, 'control.task.update')),
+        taskUpdate: managedTaskUpdateHandler(async (jobId) => {
+            const binding = await requireLocalJobBinding(jobId);
+            return { store: binding.store, repository: binding.job.repository, prNumber: binding.job.prNumber };
+        }, async (_repository, _prNumber, jobId) => pool.reconcileLocalJob(jobId, 'control.task.update')),
         taskStart: workspaceTaskStart,
         taskRetry: workspaceTaskAction('retry'),
         taskCancel: workspaceTaskAction('cancel'),
@@ -496,14 +485,18 @@ export async function runDaemon(argv) {
         }
     };
     const flushProjectionsSafely = async () => {
+        let externalActionsCompleted = 0;
         for (const writer of projectionWriters.values()) {
             try {
-                await writer.flushOnce();
+                externalActionsCompleted += (await writer.flushOnce()).projected;
             }
             catch (error) {
-                observability().record({ stage: 'daemon', event: 'daemon.projection_flush_failed', level: 'warn', outcome: 'failed', message: `GitHub projection flush unavailable: ${errorMessage(error)}`, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
+                observability().record({ stage: 'daemon', event: 'daemon.projection_flush_failed', level: 'warn', outcome: 'failed', message: `GitHub external action unavailable: ${errorMessage(error)}`, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
             }
         }
+        // GitHub external acknowledgements are audit-only. Never wake local Graphs.
+        if (externalActionsCompleted > 0)
+            observability().record({ stage: 'daemon', event: 'github.external_actions_recorded', level: 'info', outcome: 'succeeded', message: String(externalActionsCompleted) + ' external actions acknowledged without lifecycle reconciliation' });
     };
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
     let interval;
@@ -521,14 +514,16 @@ export async function runDaemon(argv) {
     await flushProjectionsSafely();
     interval = setInterval(() => void reconcileSafely().finally(flushProjectionsSafely), Number(value(argv, '--interval', String(watchdogDefault))));
     interval.unref();
-    projectionInterval = setInterval(() => void flushProjectionsSafely(), Number(value(argv, '--projection-ms', String(SERVICE_DEFAULTS.projectionFlushMs))));
-    projectionInterval.unref();
+    if (!noGitHub) {
+        projectionInterval = setInterval(() => void flushProjectionsSafely(), Number(value(argv, '--projection-ms', String(SERVICE_DEFAULTS.projectionFlushMs))));
+        projectionInterval.unref();
+    }
     scheduleInterval = setInterval(() => void scheduleHeartbeatSafely(), SCHEDULE_HEARTBEAT_MS);
     scheduleInterval.unref();
     console.log('Dashboard listening; repository worker pool active');
     void refreshAll(true)
         .then(items => pool.reconcileKnown(items))
-        .catch(error => observability().record({ stage: 'daemon', event: 'daemon.startup_refresh_failed', level: 'warn', outcome: 'failed', message: 'Startup remote refresh unavailable: ' + errorMessage(error), data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } }));
+        .catch(error => observability().record({ stage: 'daemon', event: 'daemon.startup_refresh_failed', level: 'warn', outcome: 'failed', message: 'Startup local refresh unavailable: ' + errorMessage(error), data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } }));
 }
 if (isEntrypoint(import.meta.url))
     runDaemon(process.argv.slice(2)).catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });

package/dist/runtime-status.js

@@ -12,11 +12,12 @@ export function implementationComplete(job) {
     const tasks = implementationTasks(job);
     return tasks.length > 0 && tasks.every(task => task.state === 'SUCCEEDED');
 }
-export function deriveJobRuntimeStatus(job, prState = 'OPEN') {
-    if (prState === 'MERGED')
-        return 'MERGED';
-    if (prState === 'CLOSED' || job.state === 'CANCELLED')
+export function deriveJobRuntimeStatus(job, _prState = 'OPEN') {
+    // External PR state is display metadata, never a Job runtime state input.
+    if (job.state === 'CANCELLED')
         return 'CANCELLED';
+    if (job.state === 'COMPLETED')
+        return 'COMPLETED';
     if (job.state === 'DRAFT')
         return 'IDLE';
     if (job.schedule) {
@@ -39,7 +40,7 @@ export function deriveJobRuntimeStatus(job, prState = 'OPEN') {
     if (implementation.some(task => task.state === 'QUEUED'))
         return 'QUEUED';
     const reviewRunning = job.tasks.some(task => task.agentName === 'reviewer' && task.state === 'RUNNING');
-    if (job.review?.outcome === 'approved' && prState === 'OPEN')
+    if (job.review?.outcome === 'approved')
         return 'MERGE_PENDING';
     if (reviewRunning)
         return 'REVIEWING';
@@ -53,9 +54,9 @@ export function deriveJobRuntimeStatus(job, prState = 'OPEN') {
         return 'FAILED';
     if (job.tasks.some(task => task.state === 'DRAFT'))
         return 'WAITING';
-    if (job.executionMode === 'autonomous' && job.autoMerge === false && job.reviewEnabled === false && implementationComplete(job) && prState === 'OPEN')
+    if (job.executionMode === 'autonomous' && job.autoMerge === false && job.reviewEnabled === false && implementationComplete(job))
         return 'WAITING';
-    if (job.reviewEnabled === false && implementationComplete(job) && prState === 'OPEN')
+    if (job.reviewEnabled === false && implementationComplete(job))
         return 'MERGE_PENDING';
     return 'IDLE';
 }

package/dist/scheduled-jobs.js

@@ -1,19 +1,31 @@
-import { GitHubStore } from './store.js';
 import { nextScheduleRun, scheduleBucket } from './scheduler.js';
 import { dispatchScheduledRun } from './workflow/scheduled-run-v2.js';
-async function refresh(client, repository, trustedAuthors, ref, storeFactory) {
-    const store = storeFactory ? storeFactory() : new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
-    return await store.load(ref.jobId);
-}
-export async function runScheduledBucket(client, repository, trustedAuthors, ref, engine, now = new Date(), storeFactory) {
-    let job = await refresh(client, repository, trustedAuthors, ref, storeFactory);
-    const schedule = job.schedule;
-    if (!schedule)
+/** Local-first schedule entrypoint: immutable Job ID selects the SQLite store. */
+export async function runScheduledBucketFromStore(store, ref, engine, now = new Date()) {
+    // SQLite authority provides an atomic claim. The fallback retains the
+    // existing in-memory test adapter, but cannot be used for production claims.
+    if (store.claimScheduledSlot) {
+        if (!store.finishScheduledSlot)
+            throw new Error('Atomic scheduled completion is required');
+        const claimed = await store.claimScheduledSlot(ref.jobId, ref.bucket, now);
+        if (claimed.status !== 'completed')
+            return claimed;
+        const slot = claimed.job.schedule?.currentRunSlot;
+        if (!slot)
+            throw new Error('Claimed schedule slot missing durable currentRunSlot');
+        await engine.reconcile(ref.jobId);
+        await engine.idle();
+        const job = await store.finishScheduledSlot(ref.jobId, slot, now);
+        return { job, status: 'completed' };
+    }
+    let job = await store.load(ref.jobId);
+    if (!job.schedule)
         throw new Error('Scheduled job ' + job.id + ' has no schedule metadata');
+    const schedule = job.schedule;
     const slot = new Date(schedule.nextRunAt);
     const active = job.tasks.some(task => ['QUEUED', 'RUNNING'].includes(task.state));
-    const schedulerStore = storeFactory ? storeFactory() : new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
-    let actionStatus = null;
+    let claimed = false;
+    let status = 'skipped-idempotent';
     const decision = await dispatchScheduledRun({
         slotDue: scheduleBucket(slot) === ref.bucket && slot.getTime() <= now.getTime(),
         slotUnclaimed: !schedule.lastScheduledSlot || new Date(schedule.lastScheduledSlot).getTime() < slot.getTime(),
@@ -24,37 +36,32 @@ export async function runScheduledBucket(client, repository, trustedAuthors, ref
         if (actionId === 'schedule.skipActiveAdvance') {
             schedule.lastScheduledSlot = slot.toISOString();
             schedule.nextRunAt = nextScheduleRun(schedule, now).toISOString();
-            job.updatedAt = now.toISOString();
-            await schedulerStore.saveJob(job);
-            actionStatus = 'skipped-active';
-            return {};
+            status = 'skipped-active';
         }
-        if (actionId === 'schedule.claimFromSlot' || actionId === 'schedule.claimFromNow') {
+        else if (actionId === 'schedule.claimFromSlot' || actionId === 'schedule.claimFromNow') {
             schedule.lastScheduledSlot = slot.toISOString();
             schedule.currentRunSlot = slot.toISOString();
             schedule.nextRunAt = nextScheduleRun(schedule, actionId === 'schedule.claimFromSlot' ? slot : now).toISOString();
-            job.updatedAt = now.toISOString();
-            await schedulerStore.saveJob(job);
-            job = await schedulerStore.load(job.id);
-            return {};
+            claimed = true;
+            status = 'completed';
         }
-        throw new Error('Unsupported schedule graph action ' + actionId);
+        else
+            throw new Error('Unknown local schedule action: ' + actionId);
+        job.updatedAt = now.toISOString();
+        await store.saveJob(job);
+        return {};
     });
-    if (!decision.accepted || decision.target === 'skip_idempotent')
-        return { job, status: 'skipped-idempotent' };
-    if (actionStatus === 'skipped-active' || decision.target === 'skip_active')
-        return { job, status: 'skipped-active' };
-    if (decision.target !== 'claimed')
-        return { job, status: 'skipped-idempotent' };
-    if (!engine)
-        throw new Error('Scheduled jobs require the local relayd scheduler engine');
+    if (!decision.accepted || !claimed)
+        return { job, status };
     await engine.reconcile(job.id);
     await engine.idle();
-    const finished = await schedulerStore.load(job.id);
-    if (!finished.schedule)
-        throw new Error('Scheduled job ' + job.id + ' lost its schedule metadata');
-    finished.schedule.lastRunAt = now.toISOString();
-    finished.updatedAt = now.toISOString();
-    await schedulerStore.saveJob(finished);
-    return { job: finished, status: 'completed' };
+    job = await store.load(job.id);
+    if (!job.schedule)
+        throw new Error('Scheduled job lost schedule metadata');
+    job.schedule.lastRunAt = now.toISOString();
+    // A claim and its completion can share the same wall-clock timestamp.
+    // Advance the snapshot revision to satisfy SQLite's stale-write guard.
+    job.updatedAt = new Date(Math.max(now.getTime(), Date.parse(job.updatedAt) + 1)).toISOString();
+    await store.saveJob(job);
+    return { job, status: 'completed' };
 }

package/dist/service-external-actions.js

@@ -0,0 +1,27 @@
+import { LocalAuthorityDurableStore } from './local-authority-store.js';
+import { errorMessage, observability } from './observability.js';
+export async function flushServiceExternalActions(store, reconciler, jobId) {
+    if (!(store instanceof LocalAuthorityDurableStore) || store.noGitHub)
+        return 0;
+    const result = await store.projection.flushOnce();
+    if (result.projected > 0)
+        await reconciler.reconcile(jobId);
+    return result.projected;
+}
+export function startServiceExternalActionFlusher(store, reconciler, jobId, intervalMs) {
+    if (!(store instanceof LocalAuthorityDurableStore) || store.noGitHub)
+        return () => { };
+    const tick = () => {
+        void flushServiceExternalActions(store, reconciler, jobId).catch(error => observability().record({
+            stage: 'reconcile',
+            event: 'service.external_action_flush_failed',
+            level: 'warn',
+            outcome: 'failed',
+            message: errorMessage(error),
+        }));
+    };
+    tick();
+    const timer = setInterval(tick, intervalMs);
+    timer.unref();
+    return () => clearInterval(timer);
+}