agents-relay 2.0.67 → 2.0.69

package/dist/relayd.js

@@ -1,137 +1,54 @@
 #!/usr/bin/env node
+import { consumeMethodInjection, withTestInjection } from './e2e-injection.js';
 import { once } from 'node:events';
+import { spawnOwnedProcess } from './owned-process.js';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 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, resolvePullRequest } from './store.js';
+import { GitHubProjectionWriter } from './projected-store.js';
+import { LocalAuthorityDurableStore } from './local-authority-store.js';
 import { discoverLocalRelayStoreSnapshots, relayStorePath, SQLiteRelayStore } from './relay-store.js';
+import { createJobIdRegistryResolver } from './local-job-registry.js';
+import { projectAuthoritativeLocalMerge } from './local-merge-projection.js';
+import { archiveDisplayPullRequest } from './github-pr-archive.js';
+import { orderGitHubBindingCandidates } from './github-binding-order.js';
 import { githubAuthContext } from './github-auth.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 { eventBusResolutionMessage, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, publishTaskUnblocked, resolveEventBus } from './cli-support.js';
 import { eventFor } from './events.js';
+import { dispatchTaskAction } from './task-actions.js';
+import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
+import { registerBlockerDependency } from './blockers.js';
+import { ensureManagedGitHubJob } from './cli-job-create.js';
 import { applyJobActivateAction } from './job-actions.js';
 import { applyOrchestratorStartAction, applyOrchestratorCompleteAction } from './task-actions.js';
 import { managedTaskUpdateHandler } from './task-update.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
-import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
+import { defaultWorkspaceRoot, discoverWorkspaceRepositories, ensureLocalJobSourceBranch, prepareLocalJobExecutionWorktree, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
+import { createRuntimeStatusPublisher } from './runtime-status-events.js';
+import { subscribeLocalCommits } from './local-commit-events.js';
 import { decisionMode, executionDecisionEngine } from './decision.js';
 import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
-import { executionRouterRulesPath } from './routing-policy.js';
 import { workerCandidates } from './worker-routing.js';
+import { discoverAgents } from './registry.js';
 import { shutdownOwnedProcesses } from './owned-process.js';
 import { routeExecution } from './execution-routing.js';
-import { RelayObservability, classifyFailure, errorMessage, observability, setObservability } from './observability.js';
-/** Initialize the process-wide structured observability sink once, from environment. */
-export function configureDaemonObservability(env = process.env) {
-    const configured = RelayObservability.fromEnvironment(env);
-    setObservability(configured);
-    return configured;
-}
-export async function overlayOperationalOverviews(overviews, storeFor) {
-    return await Promise.all(overviews.map(async (item) => {
-        const store = storeFor(item.job.repository, item.job.prNumber);
-        await store.hydrate?.(item.job);
-        const job = await store.load(item.job.id);
-        return { ...item, job };
-    }));
-}
-function managedOverviewKey(item) {
-    return item.job.repository + '#' + item.job.prNumber + ':' + item.job.id;
-}
-export function mergeOperationalInventory(current, discovered) {
-    const merged = new Map(current.map(item => [managedOverviewKey(item), item]));
-    for (const item of discovered)
-        merged.set(managedOverviewKey(item), item);
-    return [...merged.values()];
-}
-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());
-}
-export function shouldCoalescePullRequestRefresh(completedAt, now = Date.now(), force = false) {
-    return !force && completedAt !== null && now >= completedAt && now - completedAt < PR_REFRESH_COALESCE_MS;
-}
-export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
-
-Usage:
-  npx agents-relayd [options]
-
-Options:
-  --repo OWNER/REPO       Watch one repository
-  --workspace PATH        Discover repositories below PATH (default: ~/Workspace)
-  --port PORT             Dashboard port (default: 8787)
-  --concurrency N         Maximum concurrent workers (default: 4)
-  --interval MS           Recovery interval
-  --projection-ms MS      GitHub projection flush interval (default: 1000)
-  --execution-router-rules PATH
-                         Router Rules file (default: ~/.agents-relay/execution-router-rules.md)
-  --events nats            Require NATS event wakeups (otherwise auto-detect reachable NATS)
-
-Legacy single-job mode also accepts --repo OWNER/REPO --pr NUMBER --id JOB_ID.
-
-Examples:
-  npx agents-relayd --repo OWNER/REPO
-  npx agents-relayd --workspace ~/Workspace`;
-function firstStageChoices(decisionInput) {
-    const stages = decisionInput?.stages;
-    if (!Array.isArray(stages) || stages.length === 0)
-        return [];
-    const contract = stages[0].contract;
-    return Array.isArray(contract?.choices) ? contract.choices.filter((item) => typeof item === 'string') : [];
-}
-function value(args, name, fallback = '') { const index = args.indexOf(name); return index >= 0 ? args[index + 1] ?? fallback : fallback; }
-export function normalizeDaemonArguments(argv) {
-    const repository = value(argv, '--repo') || null;
-    const workspaceRoot = value(argv, '--workspace', defaultWorkspaceRoot()) || null;
-    const prValue = value(argv, '--pr');
-    const id = value(argv, '--id');
-    if ((prValue && !id) || (!prValue && id))
-        throw new Error('--pr and --id must be supplied together for legacy single-job mode');
-    if ((prValue || id) && !repository)
-        throw new Error('--repo is required for legacy single-job mode');
-    if (repository && argv.includes('--workspace'))
-        throw new Error('--repo and --workspace are mutually exclusive');
-    const pullRequest = prValue ? Number(prValue) : null;
-    if (pullRequest !== null && (!Number.isInteger(pullRequest) || pullRequest <= 0))
-        throw new Error('--pr must be positive');
-    return { repository, workspaceRoot: repository ? null : workspaceRoot, pullRequest, jobId: id || null, serviceArguments: [...argv] };
-}
-export function recoveryScanRepositories(repositories, cached, dormantProbeIndex = 0) {
-    const byRepository = new Map();
-    for (const item of cached) {
-        const values = byRepository.get(item.job.repository) ?? [];
-        values.push(item);
-        byRepository.set(item.job.repository, values);
-    }
-    const activeOrUnknown = [];
-    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)))
-            activeOrUnknown.push(repository);
-        else
-            dormant.push(repository);
-    }
-    if (dormant.length === 0)
-        return activeOrUnknown;
-    return [...activeOrUnknown, dormant[Math.abs(dormantProbeIndex) % dormant.length]];
-}
-export function configureExecutionRouterRulesPath(argv) {
-    const explicitRulesPath = value(argv, '--execution-router-rules') || undefined;
-    if (explicitRulesPath)
-        process.env.AGENTS_RELAY_EXECUTION_ROUTER_RULES = executionRouterRulesPath(explicitRulesPath);
-    return executionRouterRulesPath();
-}
+import { classifyFailure, errorMessage, observability } from './observability.js';
+import { createWorkspaceControl } from './relayd-control.js';
+import { createDashboardActions } from './relayd-dashboard-actions.js';
+export { daemonHelp, normalizeDaemonArguments, overlayOperationalOverviews, mergeOperationalInventory, recoveryScanRepositories, shouldCoalescePullRequestRefresh, SCHEDULE_HEARTBEAT_MS, dueScheduledOverviews, configureExecutionRouterRulesPath } from './relayd-utilities.js';
+import { configureDaemonObservability, firstStageChoices, value, daemonHelp, normalizeDaemonArguments, SCHEDULE_HEARTBEAT_MS, dueScheduledOverviews, configureExecutionRouterRulesPath } from './relayd-utilities.js';
 export async function runDaemon(argv) {
     if (argv.includes('--help') || argv.includes('-h')) {
         console.log(daemonHelp);
@@ -145,22 +62,48 @@ 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 never depends on GitHub availability, but every enabled
+    // GitHub transport must use the same authenticated context as the CLI. Probe
+    // identity separately so an auth outage is observable without blocking startup.
+    const auth = noGitHub ? null : await githubAuthContext(argv, undefined, false);
+    const client = noGitHub ? new DisabledGitHubClient() : auth.client;
+    const trusted = noGitHub ? new Set() : auth.trustedAuthors;
+    let githubAuthenticated = noGitHub ? false : null;
+    let githubAuthError = null;
+    if (!noGitHub) {
+        try {
+            const login = auth?.appAuth ? await client.currentLogin() : await client.localLogin();
+            if (!login)
+                throw new Error('gh authentication did not return a healthy login');
+            trusted.add(login);
+            githubAuthenticated = true;
+        }
+        catch (error) {
+            githubAuthenticated = false;
+            githubAuthError = errorMessage(error);
+        }
+    }
     const concurrency = Number(value(argv, '--concurrency', '4'));
     const eventResolution = await resolveEventBus([...argv]);
     const bus = eventResolution.bus;
+    const stopRuntimeStatusEvents = bus ? subscribeLocalCommits(createRuntimeStatusPublisher(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,201 +120,255 @@ 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;
     };
+    // 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)
-        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;
+        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));
+    };
+    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) => {
+            const canonical = repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot);
+            if (job.prNumber !== 0 || job.schedule)
+                return resolveRepositoryProjectPath(canonical, job.projectPath);
+            const sourceRef = await ensureLocalJobSourceBranch(canonical, job);
+            if (!store.mutateJob)
+                throw new Error('Local Job branch binding requires atomic SQLite mutation');
+            const bound = await store.mutateJob(job.id, current => current.localMerge ? current : ({ ...current, localMerge: { sourceRef, targetRef: 'refs/heads/main', status: 'pending' }, updatedAt: new Date().toISOString() }));
+            return prepareLocalJobExecutionWorktree(canonical, bound, workspaceRoot);
+        } });
+    const refreshAll = async (_full = false) => {
+        cachedOverviews = await inventoryFromLocal();
+        return cachedOverviews;
+    };
+    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 localJobBinding = createJobIdRegistryResolver(join(homedir(), '.agents-relay', 'stores'), relayStores, { client, trustedAuthors: trusted, noGitHub });
+    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 gitText = async (cwd, args) => await new Promise((resolve, reject) => {
+        const child = spawnOwnedProcess('git', ['-C', cwd, ...args], { invocation: 'workspace.git', timeoutMs: 120000, spawn: { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } } });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', chunk => { stdout += chunk.toString(); });
+        child.stderr?.on('data', chunk => { stderr += chunk.toString(); });
+        child.once('error', reject);
+        child.once('close', code => code === 0 ? resolve(stdout.trim()) : reject(new Error(stderr.trim() || `git exited ${code}`)));
+    });
+    const refreshGitHubAuthentication = async () => {
+        if (noGitHub)
+            return;
         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;
+            const login = auth?.appAuth ? await client.currentLogin() : await client.localLogin();
+            if (!login)
+                throw new Error('gh authentication did not return a healthy login');
+            trusted.add(login);
+            githubAuthenticated = true;
+            githubAuthError = null;
         }
         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;
+            githubAuthenticated = false;
+            githubAuthError = errorMessage(error);
         }
     };
-    const overviews = async (forceRefresh = false, _trigger = 'internal.unknown') => {
-        if (forceRefresh)
-            return refreshAll(true);
-        cachedOverviews = await overlayOperationalOverviews(cachedOverviews, (repository, prNumber) => runtimeStore(repository, prNumber));
-        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 = {}) => {
+    const syncGitHubBindings = async () => {
+        if (noGitHub)
+            return;
+        await refreshGitHubAuthentication();
+        if (githubAuthenticated !== true)
+            return;
         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;
+            return;
+        const snapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+        const bindingCandidates = orderGitHubBindingCandidates(snapshots.flatMap(snapshot => snapshot.jobs.map(job => ({ snapshotPath: snapshot.path, job }))));
+        for (const candidate of bindingCandidates) {
+            const snapshot = { path: candidate.snapshotPath };
+            const discovered = candidate.job;
+            try {
+                if (!repositoryPaths.has(discovered.repository) || !discovered.localMerge?.sourceRef || !discovered.localMerge?.targetRef)
+                    continue;
+                const sourceRef = discovered.localMerge.sourceRef;
+                const targetRef = discovered.localMerge.targetRef;
+                if (!sourceRef.startsWith('refs/heads/') || !targetRef.startsWith('refs/heads/'))
+                    continue;
+                if (targetRef !== 'refs/heads/main')
+                    throw new Error('GitHub sync only supports local main as merge target');
+                const branch = sourceRef.slice('refs/heads/'.length), base = targetRef.slice('refs/heads/'.length);
+                let relay = relayStores.get(snapshot.path);
+                if (!relay) {
+                    relay = new SQLiteRelayStore(snapshot.path);
+                    relayStores.set(snapshot.path, relay);
+                }
+                const canonical = repositoryPaths.get(discovered.repository) ?? await resolveManagedProjectPath(discovered.repository, explicitProjectPath, workspaceRoot);
+                // A completed local Job may never have had a display PR. Publish main
+                // regardless: GitHub availability cannot determine SQLite completion.
+                if (discovered.state === 'COMPLETED' && discovered.localMerge?.status === 'succeeded'
+                    && (discovered.externalPrNumber ?? discovered.prNumber) <= 0) {
+                    const published = projectAuthoritativeLocalMerge(canonical, discovered);
+                    if (published.status === 'projected')
+                        await bus?.publish(eventFor(discovered.id, 'projection', null, 'projection.delivered', 'succeeded', `GitHub main synchronization ${published.status}`, 'orchestrator', { operation: 'github.syncMain', deliveryStatus: published.status, mergedCommitSha: published.localMergedCommitSha }, { agent: 'relay', component: 'github-projection' }));
+                    continue;
+                }
+                const existingExternalPr = discovered.externalPrNumber ?? (discovered.prNumber > 0 ? discovered.prNumber : 0);
+                const terminal = ['COMPLETED', 'CANCELLED'].includes(discovered.state);
+                if (terminal && existingExternalPr <= 0)
+                    continue;
+                const sourceSha = await gitText(canonical, ['rev-parse', '--verify', sourceRef]);
+                const facts = await relay.loadPullRequestFacts();
+                if (facts?.head?.sha !== sourceSha) {
+                    await gitText(canonical, ['push', 'origin', `${branch}:${branch}`]);
+                }
+                let job = (await relay.loadJob(discovered.id)) ?? discovered;
+                let externalPrNumber = job.externalPrNumber ?? (job.prNumber > 0 ? job.prNumber : 0);
+                if (externalPrNumber === 0 && ['COMPLETED', 'CANCELLED'].includes(job.state))
+                    continue;
+                if (externalPrNumber === 0) {
+                    // Do not bootstrap an empty remote-only PR commit: it would diverge from
+                    // the real local Job branch before its first Worker commit. Publish the
+                    // review-only PR when there is an actual diff against main.
+                    const ahead = Number(await gitText(canonical, ['rev-list', '--count', `${targetRef}..${sourceRef}`]));
+                    if (!Number.isFinite(ahead) || ahead <= 0)
+                        continue;
+                    // GitHub compares origin/main, not local main. Do not invoke the legacy
+                    // empty-PR bootstrap path when the published base already contains the
+                    // source head (for example when main was pushed by another Job).
+                    await gitText(canonical, ['fetch', '--no-tags', 'origin', `+refs/heads/main:refs/remotes/origin/main`]);
+                    const remoteAhead = Number(await gitText(canonical, ['rev-list', '--count', `refs/remotes/origin/main..${sourceRef}`]));
+                    if (!Number.isFinite(remoteAhead) || remoteAhead <= 0)
+                        continue;
+                    const pr = await resolvePullRequest(client, job.repository, { head: branch, base, title: job.title, body: job.objective ?? job.description ?? '' });
+                    if (!relay.mutateJob)
+                        throw new Error('Atomic SQLite mutation is required for GitHub PR binding');
+                    job = await relay.mutateJob(job.id, current => ({ ...current, externalPrNumber: pr.number, updatedAt: new Date().toISOString() }));
+                    externalPrNumber = pr.number;
+                    observability().record({ stage: 'projection', event: 'github.pr_bound', outcome: 'succeeded', message: `Bound local Job ${job.id} to GitHub PR #${pr.number}`, correlation: { repository: job.repository, prNumber: pr.number, jobId: job.id }, data: { head: branch, base } });
+                }
+                if (externalPrNumber <= 0)
+                    continue;
+                const latestFacts = await relay.loadPullRequestFacts();
+                if (latestFacts?.state !== 'MERGED' && (latestFacts?.head?.sha !== sourceSha || latestFacts?.head?.ref !== branch)) {
+                    await relay.savePullRequestFacts({ state: latestFacts?.state === 'CLOSED' ? 'CLOSED' : 'OPEN', head: { ref: branch, sha: sourceSha }, observedAt: new Date().toISOString() });
+                }
+                const github = new GitHubStore(client, job.repository, externalPrNumber, trusted);
+                projectionWriters.set(`job:${job.id}`, new GitHubProjectionWriter(relay, github, undefined, true));
+                if (job.state === 'COMPLETED' && job.localMerge?.status === 'succeeded' && job.localMerge.projectionStrategy === 'target_ref_push') {
+                    const injection = await consumeMethodInjection(relay, job.repository, job.id, 'github.projectLocalMerge');
+                    const projectedMerge = await withTestInjection('github.projectLocalMerge', injection, () => projectAuthoritativeLocalMerge(canonical, job));
+                    await bus?.publish(eventFor(job.id, 'projection', null, 'projection.delivered', 'succeeded', `GitHub local merge projection ${projectedMerge.status}`, 'orchestrator', { operation: 'github.projectLocalMerge', deliveryStatus: projectedMerge.status, mergedCommitSha: projectedMerge.localMergedCommitSha }, { agent: 'relay', component: 'github-projection' }));
+                    // A review-only PR is never merged by GitHub. Close it after local main
+                    // has been safely published, retaining the diff, comments and commit link.
+                    const remotePr = await github.pullRequestState();
+                    await archiveDisplayPullRequest(client, job.repository, externalPrNumber, job.id, projectedMerge.projectedCommitSha, remotePr);
+                    const projectedState = await github.pullRequestState();
+                    const projectedHead = await github.pullRequestHead();
+                    await relay.savePullRequestFacts({ state: projectedState, head: projectedHead, observedAt: new Date().toISOString() });
+                    observability().record({
+                        stage: 'projection', event: 'github.local_merge_projected', outcome: 'succeeded',
+                        message: `Projected authoritative local merge ${projectedMerge.localMergedCommitSha} to ${projectedMerge.targetRef}`,
+                        correlation: { repository: job.repository, prNumber: externalPrNumber, jobId: job.id },
+                        data: { ...projectedMerge, githubState: projectedState },
+                    });
+                }
+            }
+            catch (error) {
+                await bus?.publish(eventFor(discovered.id, 'projection', null, 'projection.delivery_failed', 'failed', `GitHub projection failed: ${errorMessage(error)}`, 'orchestrator', { operation: 'github.projectLocalMerge', error: errorMessage(error) }, { agent: 'relay', component: 'github-projection' }))?.catch(() => { });
+                observability().record({
+                    stage: 'projection', event: 'github.binding_job_failed', level: 'warn', outcome: 'failed',
+                    message: `GitHub binding/projection failed for ${discovered.id}: ${errorMessage(error)}`,
+                    correlation: { repository: discovered.repository, prNumber: discovered.externalPrNumber ?? discovered.prNumber, jobId: discovered.id },
+                    data: { classification: classifyFailure(error).classification, reason: errorMessage(error) },
+                });
+            }
         }
-        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;
+        cachedOverviews = await inventoryFromLocal();
+    };
+    let githubBindingSyncInFlight = null;
+    const syncGitHubBindingsSafely = async () => {
+        if (githubBindingSyncInFlight)
+            return githubBindingSyncInFlight;
+        githubBindingSyncInFlight = (async () => {
+            try {
+                await syncGitHubBindings();
+            }
+            catch (error) {
+                observability().record({ stage: 'projection', event: 'github.binding_sync_failed', level: 'warn', outcome: 'failed', message: `GitHub Job binding sync failed: ${errorMessage(error)}`, data: { classification: classifyFailure(error).classification, reason: errorMessage(error) } });
+            }
+            finally {
+                githubBindingSyncInFlight = null;
+            }
         })();
-        pullRequestRefreshFlights.set(key, flight);
-        try {
-            return await flight;
-        }
-        finally {
-            if (pullRequestRefreshFlights.get(key) === flight)
-                pullRequestRefreshFlights.delete(key);
-        }
+        return githubBindingSyncInFlight;
     };
-    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 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 dashboardOverview = (jobId, target) => cachedOverviews.find(item => item.job.id === jobId
-        && (!target?.repository || item.job.repository === target.repository)
-        && (!target?.prNumber || item.job.prNumber === target.prNumber));
-    const workspaceJobAction = (action) => async (jobId) => {
-        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);
-        if (action === 'reconcile') {
-            await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId);
-            return await store.load(jobId);
-        }
-        return await dashboardJobAction(store, makeReconciler(store, concurrency), action)(jobId);
-    };
-    const workspaceJobSetState = async (jobId, 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 result = await dashboardJobSetState(store)(jobId, state);
-        await refreshPullRequest(overview.job.repository, overview.job.prNumber, 'dashboard.job-state', { force: true });
-        return result;
-    };
-    const workspaceTaskCreate = async (jobId, task) => {
-        const overview = cachedOverviews.find(item => item.job.id === jobId);
-        if (!overview)
-            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 job = await store.load(jobId);
-        if (['COMPLETED', 'CANCELLED'].includes(job.state))
-            throw new Error(`Cannot create task on terminal job ${job.id} (${job.state})`);
-        await store.appendTask(task);
-        const refreshed = await store.load(jobId);
-        if (refreshed.state === 'DRAFT') {
-            await applyJobActivateAction(refreshed);
-            await store.saveJob(refreshed);
-        }
-        await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, 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 job = await store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        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');
-        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 job = await store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        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');
-        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);
-        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 result = await dashboardTaskSetState(store)(jobId, taskId, state);
-        await refreshPullRequest(overview.job.repository, overview.job.prNumber, 'dashboard.task-state', { force: true });
-        return result;
-    };
+    const dashboardStore = fallback ? (await requireLocalJobBinding(fallback.id)).store : new InMemoryStore();
+    const { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskStart, workspaceTaskComplete, workspaceTaskAction, workspaceTaskSetState } = createDashboardActions({ cachedOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, applyOrchestratorStartAction, applyOrchestratorCompleteAction, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, bus, dashboardTaskAction, dashboardTaskSetState });
+    const workspaceControl = createWorkspaceControl({ client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, unblockAutonomousTasks, unblockTask, publishTaskUnblocked, dispatchTaskAction, registerBlockerDependency, discoverAgents, ensureManagedGitHubJob });
     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),
         wake: async (event) => {
-            const targets = cachedOverviews.filter(item => item.job.repository === event.repository && item.job.prNumber === event.pullRequest);
+            const targets = cachedOverviews.filter(item => item.job.repository === event.repository && (event.jobId ? item.job.id === event.jobId : (item.job.externalPrNumber ?? item.job.prNumber) === event.pullRequest));
             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 +381,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 +394,17 @@ 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, () => ({ githubEnabled: !noGitHub, githubAuthenticated, githubAuthError, ...client.rateLimitStatus(), readPaths: { ...githubReadPaths } }), noGitHub ? undefined : () => client.rateLimitSnapshot(), exactJob, {
+        control: workspaceControl,
         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,39 +494,46 @@ 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;
     let scheduleInterval;
     let projectionInterval;
-    const stop = () => { if (interval)
+    const stop = () => { stopRuntimeStatusEvents(); if (interval)
         clearInterval(interval); if (scheduleInterval)
         clearInterval(scheduleInterval); if (projectionInterval)
         clearInterval(projectionInterval); void Promise.allSettled([stopWatch(), shutdownOwnedProcesses('parent-shutdown')]).finally(() => { for (const store of relayStores.values())
         store.close(); server.close(() => process.exit(0)); }); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
+    await syncGitHubBindingsSafely();
     await pool.reconcileKnown(cachedOverviews);
     await scheduleHeartbeatSafely();
     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 syncGitHubBindingsSafely().then(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; });