agents-relay 1.0.177 → 2.0.0

package/dist/relay-store.js

@@ -0,0 +1,380 @@
+import { DatabaseSync } from 'node:sqlite';
+import { dirname } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+const SCHEMA_VERSION = 4;
+function newerRecord(local, remote) {
+    if (!local)
+        return structuredClone(remote);
+    return remote.updatedAt > local.updatedAt ? structuredClone(remote) : structuredClone(local);
+}
+function mergeRecords(local, remote) {
+    const remoteById = new Map(remote.map(item => [item.id, item]));
+    const merged = local.map(item => newerRecord(item, remoteById.get(item.id) ?? item));
+    const localIds = new Set(local.map(item => item.id));
+    for (const item of remote)
+        if (!localIds.has(item.id))
+            merged.push(structuredClone(item));
+    return merged;
+}
+export function mergeInboundJobSnapshot(local, remote) {
+    const base = remote.updatedAt > local.updatedAt ? structuredClone(remote) : structuredClone(local);
+    base.tasks = mergeRecords(local.tasks, remote.tasks);
+    const localPlans = local.plans ?? [];
+    const remotePlans = remote.plans ?? [];
+    if (localPlans.length > 0 || remotePlans.length > 0) {
+        base.plans = mergeRecords(localPlans, remotePlans).sort((a, b) => a.round - b.round);
+    }
+    else {
+        delete base.plans;
+    }
+    return base;
+}
+function rowToProjection(row) {
+    return {
+        id: Number(row.id),
+        idempotencyKey: row.idempotency_key,
+        coalesceKey: row.coalesce_key,
+        operation: row.operation,
+        payload: JSON.parse(row.payload_json),
+        priority: Number(row.priority),
+        attempts: Number(row.attempts),
+        nextAttemptAt: row.next_attempt_at,
+        lastError: row.last_error,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export class SQLiteRelayStore {
+    path;
+    db;
+    constructor(path) {
+        this.path = path;
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true });
+        this.db = new DatabaseSync(path);
+        this.db.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA busy_timeout=5000; PRAGMA foreign_keys=ON;');
+        this.migrate();
+        this.db.prepare("UPDATE projection_outbox SET status='pending', updated_at=? WHERE status='processing'")
+            .run(new Date().toISOString());
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS relay_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS job_snapshot (
+        job_id TEXT PRIMARY KEY,
+        json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS pull_request_facts (
+        id INTEGER PRIMARY KEY CHECK(id=1),
+        state TEXT NOT NULL CHECK(state IN ('OPEN','MERGED','CLOSED')),
+        head_ref TEXT,
+        head_sha TEXT,
+        observed_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS agent_snapshot (
+        agent_id TEXT PRIMARY KEY,
+        json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS event_receipt (
+        event_id TEXT PRIMARY KEY,
+        stream TEXT,
+        sequence INTEGER,
+        received_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS projection_outbox (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        coalesce_key TEXT,
+        operation TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        priority INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','dead')),
+        attempts INTEGER NOT NULL DEFAULT 0,
+        next_attempt_at TEXT,
+        last_error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS projection_due_idx
+        ON projection_outbox(status, next_attempt_at, priority DESC, id);
+      CREATE INDEX IF NOT EXISTS projection_coalesce_idx
+        ON projection_outbox(coalesce_key, status);
+    `);
+        const current = this.db.prepare("SELECT value FROM relay_meta WHERE key='schema_version'").get();
+        const version = current?.value ? Number(current.value) : 0;
+        if (version > SCHEMA_VERSION)
+            throw new Error(`Relay store schema ${version} is newer than supported ${SCHEMA_VERSION}`);
+        if (version < 4) {
+            const schema = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='projection_outbox'").get();
+            if (schema?.sql && !schema.sql.includes("'dead'")) {
+                this.db.exec(`
+          BEGIN IMMEDIATE;
+          DROP INDEX IF EXISTS projection_due_idx;
+          DROP INDEX IF EXISTS projection_coalesce_idx;
+          ALTER TABLE projection_outbox RENAME TO projection_outbox_v3;
+          CREATE TABLE projection_outbox (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            idempotency_key TEXT NOT NULL UNIQUE,
+            coalesce_key TEXT,
+            operation TEXT NOT NULL,
+            payload_json TEXT NOT NULL,
+            priority INTEGER NOT NULL DEFAULT 0,
+            status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','dead')),
+            attempts INTEGER NOT NULL DEFAULT 0,
+            next_attempt_at TEXT,
+            last_error TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          );
+          INSERT INTO projection_outbox(id,idempotency_key,coalesce_key,operation,payload_json,priority,status,attempts,next_attempt_at,last_error,created_at,updated_at)
+          SELECT id,idempotency_key,coalesce_key,operation,payload_json,priority,status,attempts,next_attempt_at,last_error,created_at,updated_at FROM projection_outbox_v3;
+          DROP TABLE projection_outbox_v3;
+          CREATE INDEX projection_due_idx ON projection_outbox(status, next_attempt_at, priority DESC, id);
+          CREATE INDEX projection_coalesce_idx ON projection_outbox(coalesce_key, status);
+          COMMIT;
+        `);
+            }
+        }
+        this.db.prepare("INSERT INTO relay_meta(key,value) VALUES('schema_version',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
+            .run(String(SCHEMA_VERSION));
+    }
+    async loadJob(jobId) {
+        const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
+        return row?.json ? JSON.parse(row.json) : null;
+    }
+    async listJobs() {
+        const rows = this.db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
+        return rows.map(row => JSON.parse(row.json));
+    }
+    async saveJob(job) {
+        this.writeJobSnapshot(job, new Date().toISOString());
+    }
+    async ingestJobSnapshot(job) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(job.id);
+            const local = row?.json ? JSON.parse(row.json) : null;
+            const merged = local ? mergeInboundJobSnapshot(local, job) : structuredClone(job);
+            this.writeJobSnapshot(merged, now);
+            this.db.exec('COMMIT');
+            return structuredClone(merged);
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async saveJobWithProjection(job, request) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.writeJobSnapshot(job, now);
+            this.enqueueProjectionInTransaction(request, now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    writeJobSnapshot(job, now) {
+        this.db.prepare(`
+      INSERT INTO job_snapshot(job_id,json,updated_at) VALUES(?,?,?)
+      ON CONFLICT(job_id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at
+    `).run(job.id, JSON.stringify(job), now);
+    }
+    async loadAgents() {
+        const observed = this.db.prepare("SELECT value FROM relay_meta WHERE key='agent_registry_observed_at'").get();
+        if (!observed?.value)
+            return null;
+        const rows = this.db.prepare('SELECT json FROM agent_snapshot ORDER BY agent_id').all();
+        return rows.map(row => JSON.parse(row.json));
+    }
+    async saveAgents(agents) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.prepare('DELETE FROM agent_snapshot').run();
+            const insert = this.db.prepare('INSERT INTO agent_snapshot(agent_id,json,updated_at) VALUES(?,?,?)');
+            for (const agent of agents)
+                insert.run(agent.id, JSON.stringify(agent), now);
+            this.markAgentRegistryObserved(now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async saveAgentWithProjection(agent, request) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.writeAgentSnapshot(agent, now);
+            this.markAgentRegistryObserved(now);
+            this.enqueueProjectionInTransaction(request, now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    writeAgentSnapshot(agent, now) {
+        this.db.prepare(`
+      INSERT INTO agent_snapshot(agent_id,json,updated_at) VALUES(?,?,?)
+      ON CONFLICT(agent_id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at
+    `).run(agent.id, JSON.stringify(agent), now);
+    }
+    markAgentRegistryObserved(now) {
+        this.db.prepare(`
+      INSERT INTO relay_meta(key,value) VALUES('agent_registry_observed_at',?)
+      ON CONFLICT(key) DO UPDATE SET value=excluded.value
+    `).run(now);
+    }
+    async loadPullRequestFacts() {
+        const row = this.db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get();
+        if (!row?.state || !row.observed_at)
+            return null;
+        return { state: row.state, head: row.head_ref && row.head_sha ? { ref: row.head_ref, sha: row.head_sha } : null, observedAt: row.observed_at };
+    }
+    async savePullRequestFacts(facts) {
+        this.db.prepare(`
+      INSERT INTO pull_request_facts(id,state,head_ref,head_sha,observed_at) VALUES(1,?,?,?,?)
+      ON CONFLICT(id) DO UPDATE SET state=excluded.state,head_ref=excluded.head_ref,head_sha=excluded.head_sha,observed_at=excluded.observed_at
+    `).run(facts.state, facts.head?.ref ?? null, facts.head?.sha ?? null, facts.observedAt);
+    }
+    async markEventProcessed(eventId, stream = null, sequence = null) {
+        const result = this.db.prepare(`
+      INSERT OR IGNORE INTO event_receipt(event_id,stream,sequence,received_at) VALUES(?,?,?,?)
+    `).run(eventId, stream, sequence, new Date().toISOString());
+        return Number(result.changes) === 1;
+    }
+    async enqueueProjection(request) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.enqueueProjectionInTransaction(request, now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    enqueueProjectionInTransaction(request, now) {
+        if (request.coalesceKey) {
+            this.db.prepare(`
+        DELETE FROM projection_outbox
+        WHERE coalesce_key=? AND status='pending' AND idempotency_key<>?
+      `).run(request.coalesceKey, request.idempotencyKey);
+        }
+        const existing = this.db.prepare('SELECT status FROM projection_outbox WHERE idempotency_key=?').get(request.idempotencyKey);
+        // A writer may be applying this key outside the transaction. Never rewrite its
+        // payload: its completion must only remove its own row, not a newer mutation.
+        const nextId = Number(this.db.prepare('SELECT COALESCE(MAX(id),0)+1 AS next_id FROM projection_outbox').get().next_id ?? 1);
+        const idempotencyKey = existing?.status === 'processing' || existing?.status === 'dead'
+            ? `${request.idempotencyKey}:queued:${nextId}`
+            : request.idempotencyKey;
+        this.db.prepare(`
+      INSERT INTO projection_outbox(
+        idempotency_key,coalesce_key,operation,payload_json,priority,status,
+        attempts,next_attempt_at,last_error,created_at,updated_at
+      ) VALUES(?,?,?,?,?,'pending',0,NULL,NULL,?,?)
+      ON CONFLICT(idempotency_key) DO UPDATE SET
+        coalesce_key=excluded.coalesce_key,
+        operation=excluded.operation,
+        payload_json=excluded.payload_json,
+        priority=MAX(projection_outbox.priority,excluded.priority),
+        status='pending',
+        next_attempt_at=NULL,
+        last_error=NULL,
+        updated_at=excluded.updated_at
+    `).run(idempotencyKey, request.coalesceKey ?? null, request.operation, JSON.stringify(request.payload), request.priority ?? 0, now, now);
+    }
+    async claimDueProjections(limit = 50, now = new Date()) {
+        const observedAt = now.toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const rows = this.db.prepare(`
+        SELECT id,idempotency_key,coalesce_key,operation,payload_json,priority,
+               attempts,next_attempt_at,last_error,created_at,updated_at
+        FROM projection_outbox
+        WHERE status='pending' AND (next_attempt_at IS NULL OR next_attempt_at<=?)
+        ORDER BY priority DESC, id ASC
+        LIMIT ?
+      `).all(observedAt, Math.max(1, Math.floor(limit)));
+            const mark = this.db.prepare("UPDATE projection_outbox SET status='processing', updated_at=? WHERE id=? AND status='pending'");
+            const claimed = [];
+            for (const row of rows) {
+                const result = mark.run(observedAt, row.id);
+                if (Number(result.changes) === 1)
+                    claimed.push({ ...row, updated_at: observedAt });
+            }
+            this.db.exec('COMMIT');
+            return claimed.map(rowToProjection);
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async completeProjection(id) {
+        this.db.prepare('DELETE FROM projection_outbox WHERE id=?').run(id);
+    }
+    async retryProjection(id, error, nextAttemptAt) {
+        this.db.prepare(`
+      UPDATE projection_outbox
+      SET status='pending', attempts=attempts+1, next_attempt_at=?, last_error=?, updated_at=?
+      WHERE id=?
+    `).run(nextAttemptAt.toISOString(), error, new Date().toISOString(), id);
+    }
+    async deadLetterProjection(id, error) {
+        this.db.prepare(`
+      UPDATE projection_outbox
+      SET status='dead', attempts=attempts+1, next_attempt_at=NULL, last_error=?, updated_at=?
+      WHERE id=?
+    `).run(error, new Date().toISOString(), id);
+    }
+    async pendingProjectionCount() {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM projection_outbox WHERE status IN ('pending','processing')").get();
+        return Number(row?.count ?? 0);
+    }
+    async terminalProjectionCount() {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM projection_outbox WHERE status='dead'").get();
+        return Number(row?.count ?? 0);
+    }
+    close() { this.db.close(); }
+}
+export async function discoverLocalRelayStoreSnapshots(directory) {
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return [];
+    }
+    const snapshots = [];
+    for (const name of names.filter(item => item.endsWith('.db')).sort()) {
+        const path = directory + '/' + name;
+        let store;
+        try {
+            store = new SQLiteRelayStore(path);
+            snapshots.push({ path, jobs: await store.listJobs(), facts: await store.loadPullRequestFacts() });
+        }
+        catch {
+            // Ignore unrelated/corrupt files so one bad file cannot block daemon startup.
+        }
+        finally {
+            store?.close();
+        }
+    }
+    return snapshots;
+}

package/dist/relayd.js

@@ -10,8 +10,12 @@ import { NatsEventBus } from './events.js';
 import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
 import { Reconciler } from './reconciler.js';
 import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPullRequestSnapshotGraphql, withGitHubRequestContext } from './store.js';
+import { ProjectedDurableStore } from './projected-store.js';
+import { discoverLocalRelayStoreSnapshots, SQLiteRelayStore } from './relay-store.js';
 import { githubAuthContext } from './github-auth.js';
 import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
+import { applyJobActivateAction } from './job-actions.js';
+import { applyOrchestratorCompleteAction } from './task-actions.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
@@ -19,8 +23,14 @@ import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
-import { runScheduledBucket } from './scheduled-jobs.js';
-import { scheduleBucket } from './scheduler.js';
+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 };
+    }));
+}
 const PR_REFRESH_COALESCE_MS = 1000;
 export const SCHEDULE_HEARTBEAT_MS = 600_000;
 export function dueScheduledOverviews(overviews, now = new Date()) {
@@ -40,6 +50,7 @@ Options:
   --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)
   --events nats            Enable event wakeups
 
 Legacy single-job mode also accepts --repo OWNER/REPO --pr NUMBER --id JOB_ID.
@@ -109,6 +120,20 @@ export async function runDaemon(argv) {
     let cachedOverviews = [];
     const githubReadPaths = { workspaceScans: 0, prRefreshes: 0, prRefreshesByTrigger: {}, prRefreshCoalesced: 0, prRefreshCoalescedByTrigger: {} };
     let dormantProbeIndex = 0;
+    const relayStores = new Map();
+    const projectionWriters = new Map();
+    const runtimeStore = (repository, prNumber, seed) => {
+        const key = `${repository}#${prNumber}`;
+        let relay = relayStores.get(key);
+        if (!relay) {
+            relay = new SQLiteRelayStore(join(homedir(), '.agents-relay', 'stores', `${repository.replace('/', '_')}-${prNumber}.db`));
+            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));
+        projectionWriters.set(key, projected.projection);
+        return projected;
+    };
     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: new LayaCliDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
@@ -120,7 +145,7 @@ export async function runDaemon(argv) {
             cachedOverviews = parsed;
     }
     catch { /* first run or invalid cache */ }
-    const refreshAll = async (full = false, failOnError = false) => {
+    const refreshAll = async (full = false) => {
         if (client.rateLimitStatus().limited)
             return cachedOverviews;
         const scanRepositories = full ? repositories : recoveryScanRepositories(repositories, cachedOverviews, dormantProbeIndex++);
@@ -130,7 +155,8 @@ export async function runDaemon(argv) {
             githubReadPaths.workspaceScans += 1;
             const refreshed = await withGitHubRequestContext(client, 'relayd.workspace-refresh', () => aggregateManagedGitHubJobs(client, scanRepositories, trusted));
             const scanned = new Set(scanRepositories);
-            cachedOverviews = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
+            const merged = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
+            cachedOverviews = await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber));
             try {
                 await mkdir(cacheDirectory, { recursive: true });
                 await writeFile(cacheFile, JSON.stringify(cachedOverviews), 'utf8');
@@ -139,13 +165,16 @@ export async function runDaemon(argv) {
             return cachedOverviews;
         }
         catch (error) {
-            if (failOnError)
-                throw error;
             process.stderr.write(`warning: workspace job refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
             return cachedOverviews;
         }
     };
-    const overviews = async (forceRefresh = false, _trigger = 'internal.unknown') => forceRefresh ? refreshAll(true) : cachedOverviews;
+    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 persistCache = async () => {
         try {
             await mkdir(cacheDirectory, { recursive: true });
@@ -176,12 +205,14 @@ export async function runDaemon(argv) {
         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(...snapshot.overviews);
+            cachedOverviews.push(...operational);
             cachedOverviews = dashboardManagedJobs(cachedOverviews);
             await persistCache();
-            pullRequestRefreshCache.set(key, { snapshot, completedAt: Date.now() });
-            return snapshot;
+            const operationalSnapshot = { ...snapshot, overviews: operational };
+            pullRequestRefreshCache.set(key, { snapshot: operationalSnapshot, completedAt: Date.now() });
+            return operationalSnapshot;
         })();
         pullRequestRefreshFlights.set(key, flight);
         try {
@@ -193,15 +224,15 @@ export async function runDaemon(argv) {
         }
     };
     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));
+    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 initial = cachedOverviews;
     const fallback = initial[0]?.job;
-    const dashboardStore = fallback ? new GitHubStore(client, fallback.repository, fallback.prNumber, trusted) : new InMemoryStore();
+    const dashboardStore = fallback ? runtimeStore(fallback.repository, fallback.prNumber) : new InMemoryStore();
     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 = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        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);
@@ -212,23 +243,56 @@ 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 = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        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 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 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 = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        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) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        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;
@@ -273,13 +337,14 @@ export async function runDaemon(argv) {
         reconcile: workspaceJobAction('reconcile'),
         cancel: workspaceJobAction('cancel'),
         jobSetState: workspaceJobSetState,
+        taskCreate: workspaceTaskCreate,
         taskRetry: workspaceTaskAction('retry'),
         taskCancel: workspaceTaskAction('cancel'),
+        taskComplete: workspaceTaskComplete,
         taskSetState: workspaceTaskSetState,
     });
+    await once(server, 'listening');
     const reconcileSafely = async () => {
-        if (client.rateLimitStatus().limited)
-            return;
         try {
             await pool.reconcile();
         }
@@ -288,37 +353,65 @@ export async function runDaemon(argv) {
         }
     };
     const scheduleHeartbeatSafely = async () => {
-        if (client.rateLimitStatus().limited)
-            return;
         const now = new Date();
         for (const item of dueScheduledOverviews(cachedOverviews, now)) {
-            const repository = item.job.repository;
             try {
-                await runScheduledBucket(client, repository, trusted, { prNumber: item.job.prNumber, jobId: item.job.id, bucket: scheduleBucket(new Date(item.job.schedule.nextRunAt)) }, { reconcile: async () => { await pool.reconcileTarget(repository, item.job.prNumber, item.job.id); }, idle: async () => { } }, now);
+                await pool.scheduleTickSignal(bus, item.job, now);
+            }
+            catch (error) {
+                process.stderr.write(`warning: scheduled heartbeat unavailable for ${item.job.repository}#${item.job.prNumber}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    };
+    const flushProjectionsSafely = async () => {
+        for (const writer of projectionWriters.values()) {
+            try {
+                await writer.flushOnce();
             }
             catch (error) {
-                process.stderr.write(`warning: scheduled heartbeat unavailable for ${repository}#${item.job.prNumber}: ${error instanceof Error ? error.message : String(error)}\n`);
+                process.stderr.write(`warning: GitHub projection flush unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
             }
         }
     };
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
     let interval;
     let scheduleInterval;
+    let projectionInterval;
     const stop = () => { if (interval)
         clearInterval(interval); if (scheduleInterval)
-        clearInterval(scheduleInterval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
+        clearInterval(scheduleInterval); if (projectionInterval)
+        clearInterval(projectionInterval); void stopWatch().finally(() => { for (const store of relayStores.values())
+        store.close(); server.close(() => process.exit(0)); }); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
-    await once(server, 'listening');
-    const startupItems = await refreshAll(true, true); // void refreshAll(true)
-    await pool.reconcileKnown(startupItems);
-    // Startup recovery must finish before normal polling or scheduled work can run.
+    const localSnapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+    const knownRepositories = new Set(repositories);
+    const localOverviews = 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 byJob = new Map();
+    for (const item of cachedOverviews)
+        byJob.set(item.job.repository + '#' + item.job.prNumber + ':' + item.job.id, item);
+    for (const item of localOverviews)
+        byJob.set(item.job.repository + '#' + item.job.prNumber + ':' + item.job.id, item);
+    cachedOverviews = dashboardManagedJobs([...byJob.values()]);
+    await pool.reconcileKnown(cachedOverviews);
     await scheduleHeartbeatSafely();
-    interval = setInterval(() => void reconcileSafely(), Number(value(argv, '--interval', String(watchdogDefault))));
+    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();
     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 => process.stderr.write('warning: startup remote refresh unavailable: ' + (error instanceof Error ? error.message : String(error)) + '\n'));
 }
 if (isEntrypoint(import.meta.url))
     runDaemon(process.argv.slice(2)).catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });