agents-relay 2.0.97 → 2.0.99

package/dist/cli-help.js

@@ -46,7 +46,7 @@ Common options:
   --pr NUMBER             Existing PR number
 
 Example:
-  npx agents-relay job show --repo OWNER/REPO --pr 12 --id job-1`,
+  npx agents-relay job show --repo OWNER/REPO --pr 12 --id 101`,
     review: `Request a new SHA-bound reviewer turn through the existing Relay lifecycle.
 
 Usage: npx agents-relay review request --repo OWNER/REPO --pr NUMBER --id JOB_ID [--thread-id THREAD_ID]
@@ -58,15 +58,15 @@ Required: --repo OWNER/REPO --pr NUMBER --id JOB_ID.
 Optional: --thread-id THREAD_ID persists a reviewer override; omitted uses Job reviewer/creator thread or legacy route. Rejects pending reviews and wakes managed reconciliation.`,
     'job create': `Create a SQLite-authoritative Job (objective-only).
 
-Required: --repo OWNER/REPO and a standalone Job objective. Job ID defaults to an auto-incrementing store-global number; --id is optional for compatibility. Existing PR adoption is an explicit separate command: job adopt.
+Required: --repo OWNER/REPO and a standalone Job objective. Job ID defaults to an auto-incrementing store-global number; --id may only reference an existing numeric Job. Existing PR adoption is an explicit separate command: job adopt.
 Common: --id JOB_ID (optional), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --initial-plan, --no-review, --tag JSON, --reviewer-thread-id ID, --creator-thread-id ID, --implementation-thread-id ID. --objective and --objective-file are mutually exclusive.
 Job creation always enables auto-merge. By default it is create-only; --initial-plan validates the first real Planner round before atomically creating the durable Job and Plan, then publishes the normal wake so Relay can continue without a second orchestrator command. Re-running create against an already healthy Job is idempotent and does not mutate its metadata.
 
 Example:
   npx agents-relay job create --repo OWNER/REPO --project-path vlog --title "Episode" --objective-file episode.md --initial-plan`,
-    'job adopt': `Adopt an existing legacy PR as a SQLite-authoritative Job.
+    'job adopt': `Adopt an existing PR as a SQLite-authoritative Job.
 
-Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. This is the only creation path that binds an existing PR.`,
+Required: --repo OWNER/REPO and --pr NUMBER. The Job ID is allocated atomically from the global SQLite sequence. Optional --id references an already-existing numeric Job only.`,
     'job update': `Partially update mutable metadata on a healthy existing Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
@@ -74,13 +74,13 @@ Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, -
 Unspecified fields are preserved. Local Job/PR identity mismatch is rejected.
 
 Example:
-  npx agents-relay job update --repo OWNER/REPO --pr 12 --id job-1 --priority P0 --no-auto-merge`,
+  npx agents-relay job update --repo OWNER/REPO --pr 12 --id 101 --priority P0 --no-auto-merge`,
     'job show': `Show one durable Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
 
 Example:
-  npx agents-relay job show --repo OWNER/REPO --pr 12 --id job-1`,
+  npx agents-relay job show --repo OWNER/REPO --pr 12 --id 101`,
     'job list': `List managed Jobs in a repository.
 
 Required: --repo OWNER/REPO.
@@ -130,7 +130,7 @@ Mutable while not RUNNING/SUCCEEDED/CANCELLED: --title, --adapter, --priority, -
 Use --clear-routing to remove routing metadata.
 
 Example:
-  npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id build --adapter chatgpt --provider chatgpt --model gpt-5.6-sol --reasoning high`,
+  npx agents-relay task update --repo OWNER/REPO --pr 12 --id 101 --task-id build --adapter chatgpt --provider chatgpt --model gpt-5.6-sol --reasoning high`,
     'task comment': `Append an immutable Task comment. Does not retry or change Task state.
 
 Required: --repo OWNER/REPO --id JOB_ID --task-id TASK_ID and --message TEXT or --message-file FILE.`,
@@ -166,7 +166,7 @@ Optional: --prompt TEXT or --prompt-file PATH|- (mutually exclusive). The prompt
 The command persists one real plan-N round, materializes validated next_tasks with planner provenance, and wakes normal reconciliation. It works for zero-task DRAFT Jobs. Historical planner-N rounds remain readable, but new rounds use plan-N.
 
 Example:
-  npx agents-relay plan --repo OWNER/REPO --pr 12 --id job-1 --prompt "Plan the full implementation now; keep independent work parallel."`,
+  npx agents-relay plan --repo OWNER/REPO --pr 12 --id 101 --prompt "Plan the full implementation now; keep independent work parallel."`,
     blocker: `Manage durable cross-Job blocker dependencies.
 
 Usage:
@@ -211,20 +211,20 @@ Required: --file PATH for local demo mode, or --repo OWNER/REPO --pr NUMBER --id
 Managed GitHub jobs are reconciled by agents-relayd. The CLI publishes a job.wake request and does not launch workers; NATS is auto-detected when reachable; use --events nats to require it explicitly. Local/runtime invocations may use --thread-id ID to override the durable reviewer/creator thread for ChatGPT review delivery.
 
 Example:
-  npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1`,
+  npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id 101`,
     init: `Initialize a new job. GitHub mode requires --repo and --pr; local mode requires explicit --file.
 
 Common: --id ID, --title TEXT, --objective TEXT, --mode fixed|autonomous, --priority P0|P1|P2|P3.
 
 Example:
-  npx agents-relay init --repo OWNER/REPO --pr 12 --id job-1 --title "Objective"`,
+  npx agents-relay init --repo OWNER/REPO --pr 12 --id 101 --title "Objective"`,
     serve: `Run the dashboard and reconciliation service for a managed job.
 
 Required: --file PATH for local demo mode, or --repo OWNER/REPO --pr NUMBER --id JOB_ID.
 Common: --port PORT, --interval MS, --events nats (optional; reachable NATS is auto-detected), --thread-id ID (reviewer-thread override).
 
 Example:
-  npx agents-relay serve --repo OWNER/REPO --pr 12 --id job-1`,
+  npx agents-relay serve --repo OWNER/REPO --pr 12 --id 101`,
     'agent-register': `Register an agent role and its execution endpoint.
 
 Required for durable service mode: --repo OWNER/REPO --id JOB_ID plus --name NAME --responsibility TEXT --role ROLE --endpoint TARGET. Use --file only for explicit demo mode.

package/dist/cli-job-create.js

@@ -5,10 +5,12 @@ import { normalizeThreadId } from './reviewer-thread.js';
 import { discoverLocalRelayStoreSnapshots, relayStoreDirectory } from './relay-store.js';
 /**
  * Ordinary Job creation is local and objective-oriented. Legacy PR metadata is
- * handled by adoptLegacyJob below so the normal contract cannot accidentally
+ * handled by adoptExistingPullRequestJob below so the normal contract cannot accidentally
  * create a second external lifecycle.
  */
 export async function ensureManagedGitHubJob(_client, repositoryName, _trustedAuthors, options) {
+    if (options.id && !/^[1-9][0-9]*$/.test(options.id))
+        throw new Error('Job ID must be a positive decimal integer');
     const directory = options.storeDirectory ?? relayStoreDirectory();
     const knownJobs = (await discoverLocalRelayStoreSnapshots(directory)).flatMap(snapshot => snapshot.jobs);
     const id = options.id || allocateEntityId(directory, repositoryName, 'job', options.idempotencyKey, new Set(knownJobs.map(job => job.id)));
@@ -88,27 +90,33 @@ export async function ensureManagedGitHubJob(_client, repositoryName, _trustedAu
         local.relay.close();
     }
 }
-/** Explicit compatibility path for adopting an already-existing PR. */
-export async function adoptLegacyJob(_client, repositoryName, _trustedAuthors, options) {
-    if (!options.id || !Number.isInteger(options.prNumber) || options.prNumber <= 0)
-        throw new Error('job adopt requires --id and a positive --pr');
+/** Import an existing PR without letting external labels choose the durable numeric Job ID. */
+export async function adoptExistingPullRequestJob(_client, repositoryName, _trustedAuthors, options) {
+    if (!Number.isInteger(options.prNumber) || options.prNumber <= 0)
+        throw new Error('job adopt requires a positive --pr');
+    if (options.id && !/^[1-9][0-9]*$/.test(options.id))
+        throw new Error('Job ID must be a positive decimal integer');
     const directory = options.storeDirectory ?? relayStoreDirectory();
-    const matches = (await discoverLocalRelayStoreSnapshots(directory)).flatMap(snapshot => snapshot.jobs).filter(job => job.id === options.id);
+    const knownJobs = (await discoverLocalRelayStoreSnapshots(directory)).flatMap(snapshot => snapshot.jobs);
+    const matches = options.id ? knownJobs.filter(job => job.id === options.id) : knownJobs.filter(job => job.repository === repositoryName && job.prNumber === options.prNumber);
     if (matches.length > 1)
-        throw new Error(`Ambiguous existing immutable Job ID ${options.id}`);
+        throw new Error('Ambiguous existing immutable Job or PR binding');
     if (matches.length === 1) {
         const existing = matches[0];
         if (existing.repository !== repositoryName || existing.prNumber !== options.prNumber)
             throw new Error(`Job ID ${options.id} is already bound to another repository or PR`);
         return { job: existing, pr: { number: existing.prNumber, title: existing.title, body: existing.objective ?? '', state: 'OPEN', head: '', base: 'main' } };
     }
-    const local = openLocalManagedStore(repositoryName, options.prNumber, { directory, jobId: options.id, noGitHub: true });
+    if (options.id)
+        throw new Error(`Unknown numeric Job ID ${options.id}; new PR adoptions allocate IDs automatically`);
+    const id = allocateEntityId(directory, repositoryName, 'job', `adopt:pr:${options.prNumber}`, new Set(knownJobs.map(job => job.id)));
+    const local = openLocalManagedStore(repositoryName, options.prNumber, { directory, jobId: id, noGitHub: true });
     try {
-        const existing = await local.relay.loadJob(options.id);
+        const existing = (await local.relay.listJobs()).find(job => job.repository === repositoryName && job.prNumber === options.prNumber);
         if (existing)
-            return { job: existing, pr: { number: existing.prNumber, title: existing.title, body: existing.objective ?? '', state: 'OPEN', head: '', base: '' } };
+            return { job: existing, pr: { number: existing.prNumber, title: existing.title, body: existing.objective ?? '', state: 'OPEN', head: '', base: 'main' } };
         const now = new Date().toISOString();
-        const job = createJobEntity({ id: options.id, title: options.title ?? options.id, objective: options.objective, projectPath: options.projectPath,
+        const job = createJobEntity({ id, title: options.title ?? id, objective: options.objective, projectPath: options.projectPath,
             description: options.objective, priority: 'P2', executionMode: 'fixed', autoMerge: true, reviewEnabled: true,
             prNumber: options.prNumber, repository: repositoryName, continuation: null, createdAt: now, updatedAt: now, tasks: [] });
         const created = local.store.createJobIfAbsent ? await local.store.createJobIfAbsent(job) : (await local.store.saveJob(job), job);

package/dist/cli.js

@@ -384,11 +384,11 @@ async function runJobCommand(action, args) {
     if (action === 'adopt') {
         const adoptId = arg(args, '--id');
         const adoptPr = Number(arg(args, '--pr'));
-        if (!adoptId || !Number.isInteger(adoptPr) || adoptPr <= 0)
-            throw new Error('job adopt requires --id and a positive --pr');
+        if (!Number.isInteger(adoptPr) || adoptPr <= 0)
+            throw new Error('job adopt requires a positive --pr');
         const objective = await textOption(args, '--objective', '--objective-file');
         const result = await relayControlCommand(args, { command: 'job.adopt', repository: repo, options: {
-                id: adoptId, prNumber: adoptPr, title: arg(args, '--title') || undefined, objective: objective || undefined, projectPath: arg(args, '--project-path') || undefined,
+                id: adoptId || undefined, prNumber: adoptPr, title: arg(args, '--title') || undefined, objective: objective || undefined, projectPath: arg(args, '--project-path') || undefined,
             } });
         console.log(JSON.stringify(result, null, 2));
         return;

package/dist/job-task-id-sequence.js

@@ -1,34 +1,25 @@
 import { DatabaseSync } from 'node:sqlite';
 import { mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-export function generatedEntityPrefix(repository, kind) {
-    const [owner, repo] = repository.split('/');
-    if (!owner || !repo || !/^[\w.-]+$/.test(owner) || !/^[\w.-]+$/.test(repo) || owner === '..' || repo === '..')
+import { join, dirname } from 'node:path';
+function validateRepository(repository) {
+    const [owner, repo, extra] = repository.split('/');
+    if (!owner || !repo || extra || !/^[\w.-]+$/.test(owner) || !/^[\w.-]+$/.test(repo) || owner === '..' || repo === '..')
         throw new Error('Invalid repository');
-    return `${kind === 'job' ? 'j' : 't'}-${owner.length}-${owner}-${repo}-`;
 }
-export function isGeneratedEntityId(id, repository, kind) {
-    if (kind === 'task') {
-        if (/^[1-9][0-9]*$/.test(id))
-            return true;
-        const legacyPrefix = generatedEntityPrefix(repository, kind);
-        return id.startsWith(legacyPrefix) && /^[0-9]+$/.test(id.slice(legacyPrefix.length));
-    }
-    if (/^[1-9][0-9]*$/.test(id))
-        return true;
-    const prefix = generatedEntityPrefix(repository, kind);
-    return id.startsWith(prefix) && /^[0-9]+$/.test(id.slice(prefix.length));
+/** A generated ID is always a positive decimal. Historic nonnumeric Task IDs remain ordinary Task identifiers. */
+export function isGeneratedEntityId(id, _repository, _kind) {
+    return /^[1-9][0-9]*$/.test(id);
 }
-/** Job and Task IDs each use their own store-global sequence. SQLite serializes allocation; legacy identifiers remain readable. */
+/** Job and Task IDs each use their own store-global sequence. SQLite serializes allocation. */
 export function allocateEntityId(directory, repository, kind, requestKey, occupied = new Set()) {
-    generatedEntityPrefix(repository, kind); // validate repository even though its name no longer appears in the ID
+    validateRepository(repository);
     const prefix = '';
     const scope = '*';
     const scopedRequestKey = requestKey ? `${repository}:${requestKey}` : undefined;
     if (requestKey !== undefined && (!requestKey || requestKey.length > 512))
         throw new Error('Invalid idempotency key');
     mkdirSync(directory, { recursive: true });
-    const db = new DatabaseSync(join(directory, 'entity-id-sequences.sqlite'));
+    const db = new DatabaseSync(process.env.AGENTS_RELAY_SQLITE_MODE === 'unified' ? join(dirname(directory), 'relay.sqlite') : join(directory, 'entity-id-sequences.sqlite'));
     try {
         db.exec('PRAGMA journal_mode=WAL; PRAGMA busy_timeout=10000;');
         db.exec('CREATE TABLE IF NOT EXISTS sequences (repository TEXT NOT NULL, kind TEXT NOT NULL, value INTEGER NOT NULL, PRIMARY KEY(repository,kind)); CREATE TABLE IF NOT EXISTS idempotency (repository TEXT NOT NULL, kind TEXT NOT NULL, request_key TEXT NOT NULL, entity_id TEXT NOT NULL, PRIMARY KEY(repository,kind,request_key));');

package/dist/local-job-registry.js

@@ -1,6 +1,6 @@
 import { GitHubStore, InMemoryStore } from './store.js';
 import { LocalAuthorityDurableStore } from './local-authority-store.js';
-import { discoverLocalRelayStoreSnapshots, SQLiteRelayStore } from './relay-store.js';
+import { discoverLocalRelayStoreSnapshots, unifiedRelayStoreEnabled, SQLiteRelayStore } from './relay-store.js';
 /** Resolve exactly one SQLite-backed Job from its immutable ID, independent of PR binding. */
 export function createJobIdRegistryResolver(directory, openStores, options = {}) {
     return async (jobId) => {
@@ -12,10 +12,11 @@ export function createJobIdRegistryResolver(directory, openStores, options = {})
         if (!selected)
             return null;
         const { snapshot, job } = selected;
-        let relay = openStores.get(snapshot.path);
+        const scopedKey = unifiedRelayStoreEnabled() ? `${snapshot.path}#${job.id}` : snapshot.path;
+        let relay = openStores.get(scopedKey);
         if (!relay) {
-            relay = new SQLiteRelayStore(snapshot.path);
-            openStores.set(snapshot.path, relay);
+            relay = new SQLiteRelayStore(snapshot.path, unifiedRelayStoreEnabled() ? job.id : undefined);
+            openStores.set(scopedKey, relay);
         }
         // SQLite remains lifecycle authority. A positive PR binding only enables
         // the external collaboration adapter for projection/merge side effects.

package/dist/local-managed-store.js

@@ -2,18 +2,20 @@ import { GhApiClient } from './github-client.js';
 import { DisabledGitHubClient, noGitHubMode } from './no-github.js';
 import { GitHubStore } from './store.js';
 import { LocalAuthorityDurableStore } from './local-authority-store.js';
-import { relayStoreDirectory, relayStorePath, relayJobStorePath, SQLiteRelayStore } from './relay-store.js';
+import { relayStoreDirectory, relayStorePath, relayJobStorePath, relayUnifiedStorePath, unifiedRelayStoreEnabled, resolveUnifiedJobScope, SQLiteRelayStore } from './relay-store.js';
 /** Open the canonical V2 SQLite authority without making any GitHub request. */
 export function openLocalManagedStore(repository, prNumber, options = {}) {
     if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository) || repository.includes('..') || !Number.isInteger(prNumber) || prNumber < 0 || (prNumber === 0 && !options.jobId)) {
         throw new Error('Local managed store requires a repository and either a positive PR number or immutable jobId');
     }
     const directory = options.directory ?? relayStoreDirectory();
-    const relay = new SQLiteRelayStore(prNumber === 0 ? relayJobStorePath(directory, options.jobId) : relayStorePath(directory, repository, prNumber));
+    const unified = unifiedRelayStoreEnabled();
+    const scope = unified ? resolveUnifiedJobScope(directory, repository, prNumber, options.jobId) : undefined;
+    const relay = new SQLiteRelayStore(unified ? relayUnifiedStorePath(directory) : (prNumber === 0 ? relayJobStorePath(directory, options.jobId) : relayStorePath(directory, repository, prNumber)), scope);
     const client = prNumber === 0 || options.noGitHub || noGitHubMode() ? new DisabledGitHubClient() : options.client ?? new GhApiClient();
     const github = new GitHubStore(client, repository, prNumber, options.trustedAuthors ?? new Set());
     return {
         relay,
-        store: new LocalAuthorityDurableStore(relay, github, (relatedRepository, relatedPr) => openLocalManagedStore(relatedRepository, relatedPr, options).store, options.noGitHub || noGitHubMode()),
+        store: new LocalAuthorityDurableStore(relay, github, (relatedRepository, relatedPr) => openLocalManagedStore(relatedRepository, relatedPr, { ...options, jobId: undefined }).store, options.noGitHub || noGitHubMode()),
     };
 }

package/dist/projection-outbox.js

@@ -56,8 +56,14 @@ const OUTBOX_COLUMNS = 'id,idempotency_key,operation_key,coalesce_key,operation,
  */
 export class ProjectionOutbox {
     db;
-    constructor(db) {
+    scopeJobId;
+    constructor(db, scopeJobId) {
         this.db = db;
+        this.scopeJobId = scopeJobId;
+    }
+    get scopeAnd() { return this.scopeJobId ? ' AND scope_job_id=?' : ''; }
+    bind(...params) {
+        return this.scopeJobId ? [...params, this.scopeJobId] : params;
     }
     static createTableSql(table = 'projection_outbox') {
         return `CREATE TABLE IF NOT EXISTS ${table} (
@@ -146,7 +152,7 @@ export class ProjectionOutbox {
     }
     resetProcessing(now) {
         const cutoff = new Date(Date.parse(now) - 120_000).toISOString();
-        this.db.prepare("UPDATE projection_outbox SET status='pending', updated_at=? WHERE status='processing' AND updated_at<=?").run(now, cutoff);
+        this.db.prepare(`UPDATE projection_outbox SET status='pending', updated_at=? WHERE status='processing' AND updated_at<=?${this.scopeAnd}`).run(...this.bind(now, cutoff));
     }
     enqueue(request, now) {
         const operationKey = logicalOperationKey(request.idempotencyKey);
@@ -154,20 +160,32 @@ export class ProjectionOutbox {
         if (request.coalesceKey) {
             const removed = this.db.prepare(`
         DELETE FROM projection_outbox
-        WHERE coalesce_key=? AND status='pending' AND operation_key<>?
-      `).run(request.coalesceKey, operationKey);
+        WHERE coalesce_key=? AND status='pending' AND operation_key<>?${this.scopeAnd}
+      `).run(...this.bind(request.coalesceKey, operationKey));
             coalesced = Number(removed.changes) > 0;
         }
-        const existing = this.db.prepare('SELECT status FROM projection_outbox WHERE operation_key=? ORDER BY id DESC LIMIT 1')
-            .get(operationKey);
+        const existing = this.db.prepare(`SELECT status FROM projection_outbox WHERE operation_key=?${this.scopeAnd} ORDER BY id DESC LIMIT 1`)
+            .get(...this.bind(operationKey));
         // A writer may be applying this key outside the transaction, or a deterministic
         // conflict may already be recorded for it. Never rewrite that row's payload: its
         // completion must only remove its own row, and a recorded conflict must stay the
         // classification evidence until explicitly repaired. New mutations queue beside it.
-        const nextId = Number(this.db.prepare('SELECT COALESCE(MAX(id),0)+1 AS next_id FROM projection_outbox').get().next_id ?? 1);
+        const nextId = Number(this.db.prepare(`SELECT COALESCE(MAX(id),0)+1 AS next_id FROM projection_outbox${this.scopeJobId ? ' WHERE scope_job_id=?' : ''}`).get(...(this.scopeJobId ? [this.scopeJobId] : [])).next_id ?? 1);
         const collides = existing?.status === 'processing' || existing?.status === 'conflict' || existing?.status === 'dead';
         const idempotencyKey = collides ? `${operationKey}:queued:${nextId}` : operationKey;
-        this.db.prepare(`
+        const insertSql = this.scopeJobId ? `
+      INSERT INTO projection_outbox(
+        scope_job_id,id,idempotency_key,operation_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(scope_job_id,idempotency_key) DO UPDATE SET
+        operation_key=excluded.operation_key,
+        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
+    ` : `
       INSERT INTO projection_outbox(
         idempotency_key,operation_key,coalesce_key,operation,payload_json,priority,status,
         attempts,next_attempt_at,last_error,created_at,updated_at
@@ -178,11 +196,11 @@ export class ProjectionOutbox {
         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, operationKey, request.coalesceKey ?? null, request.operation, JSON.stringify(request.payload), request.priority ?? 0, now, now);
+        status='pending', next_attempt_at=NULL, last_error=NULL, updated_at=excluded.updated_at
+    `;
+        const params = [idempotencyKey, operationKey, request.coalesceKey ?? null,
+            request.operation, JSON.stringify(request.payload), request.priority ?? 0, now, now];
+        this.db.prepare(insertSql).run(...(this.scopeJobId ? [this.scopeJobId, nextId, ...params] : params));
         return coalesced;
     }
     claimDue(limit, now) {
@@ -193,14 +211,14 @@ export class ProjectionOutbox {
             const rows = this.db.prepare(`
         SELECT ${OUTBOX_COLUMNS}
         FROM projection_outbox
-        WHERE status='pending' AND (next_attempt_at IS NULL OR next_attempt_at<=?)
+        WHERE status='pending' AND (next_attempt_at IS NULL OR next_attempt_at<=?)${this.scopeAnd}
         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'");
+      `).all(observedAt, ...(this.scopeJobId ? [this.scopeJobId] : []), Math.max(1, Math.floor(limit)));
+            const mark = this.db.prepare(`UPDATE projection_outbox SET status='processing', updated_at=? WHERE id=? AND status='pending'${this.scopeAnd}`);
             const claimed = [];
             for (const row of rows) {
-                const result = mark.run(observedAt, row.id);
+                const result = mark.run(...this.bind(observedAt, row.id));
                 if (Number(result.changes) === 1)
                     claimed.push({ ...row, updated_at: observedAt });
             }
@@ -213,13 +231,13 @@ export class ProjectionOutbox {
         }
     }
     complete(id) {
-        this.db.prepare('DELETE FROM projection_outbox WHERE id=?').run(id);
+        this.db.prepare(`DELETE FROM projection_outbox WHERE id=?${this.scopeAnd}`).run(...this.bind(id));
     }
     completeWithReceipt(id, operationKey, status, attempts, detail, now) {
         this.db.exec('BEGIN IMMEDIATE');
         try {
             this.recordReceipt(operationKey, status, attempts, detail, now);
-            this.db.prepare('DELETE FROM projection_outbox WHERE id=?').run(id);
+            this.db.prepare(`DELETE FROM projection_outbox WHERE id=?${this.scopeAnd}`).run(...this.bind(id));
             this.db.exec('COMMIT');
         }
         catch (error) {
@@ -231,8 +249,8 @@ export class ProjectionOutbox {
         this.db.exec('BEGIN IMMEDIATE');
         try {
             this.db.prepare(`UPDATE projection_outbox
-        SET status='pending', attempts=?, next_attempt_at=?, last_error=?, updated_at=? WHERE id=?`)
-                .run(attempts, nextAttemptAt.toISOString(), error, now, id);
+        SET status='pending', attempts=?, next_attempt_at=?, last_error=?, updated_at=? WHERE id=?${this.scopeAnd}`)
+                .run(...this.bind(attempts, nextAttemptAt.toISOString(), error, now, id));
             this.recordReceipt(operationKey, 'failed', attempts, detail, now);
             this.db.exec('COMMIT');
         }
@@ -245,20 +263,27 @@ export class ProjectionOutbox {
         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);
+      WHERE id=?${this.scopeAnd}
+    `).run(...this.bind(nextAttemptAt.toISOString(), error, new Date().toISOString(), id));
     }
     deadLetter(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);
+      WHERE id=?${this.scopeAnd}
+    `).run(...this.bind(error, new Date().toISOString(), id));
     }
     recordReceipt(operationKey, status, attempts, detail, now) {
-        this.db.prepare(`INSERT INTO projection_receipt(operation_key,status,attempts,detail_json,recorded_at)
-      VALUES(?,?,?,?,?) ON CONFLICT(operation_key) DO UPDATE SET status=excluded.status, attempts=excluded.attempts,
-      detail_json=excluded.detail_json, recorded_at=excluded.recorded_at`).run(operationKey, status, attempts, JSON.stringify(detail ?? null), now);
+        if (this.scopeJobId) {
+            this.db.prepare(`INSERT INTO projection_receipt(scope_job_id,operation_key,status,attempts,detail_json,recorded_at)
+        VALUES(?,?,?,?,?,?) ON CONFLICT(scope_job_id,operation_key) DO UPDATE SET status=excluded.status, attempts=excluded.attempts,
+        detail_json=excluded.detail_json, recorded_at=excluded.recorded_at`).run(this.scopeJobId, operationKey, status, attempts, JSON.stringify(detail ?? null), now);
+        }
+        else {
+            this.db.prepare(`INSERT INTO projection_receipt(operation_key,status,attempts,detail_json,recorded_at)
+        VALUES(?,?,?,?,?) ON CONFLICT(operation_key) DO UPDATE SET status=excluded.status, attempts=excluded.attempts,
+        detail_json=excluded.detail_json, recorded_at=excluded.recorded_at`).run(operationKey, status, attempts, JSON.stringify(detail ?? null), now);
+        }
     }
     recordConflict(id, diagnostic) {
         const evidence = JSON.stringify({
@@ -274,19 +299,19 @@ export class ProjectionOutbox {
       SET status='conflict', attempts=attempts+1, next_attempt_at=NULL, last_error=?,
           conflict_definition_json=?, conflict_evidence_json=?, conflict_detected_at=?,
           conflict_disposition='awaiting_repair', conflict_resolution_json=NULL, updated_at=?
-      WHERE id=? AND status NOT IN ('conflict','dead')
-    `).run(diagnostic.message, JSON.stringify(diagnostic.localDefinition), evidence, diagnostic.detectedAt, diagnostic.detectedAt, id);
+      WHERE id=? AND status NOT IN ('conflict','dead')${this.scopeAnd}
+    `).run(...this.bind(diagnostic.message, JSON.stringify(diagnostic.localDefinition), evidence, diagnostic.detectedAt, diagnostic.detectedAt, id));
     }
     listConflicts() {
         const rows = this.db.prepare(`
-      SELECT ${OUTBOX_COLUMNS} FROM projection_outbox WHERE status='conflict' ORDER BY id ASC
-    `).all();
+      SELECT ${OUTBOX_COLUMNS} FROM projection_outbox WHERE status='conflict'${this.scopeAnd} ORDER BY id ASC
+    `).all(...(this.scopeJobId ? [this.scopeJobId] : []));
         return rows.map(rowToConflict);
     }
     /** Explicit repair: requeue the original projection, or discard the blocked local mutation for a fresh one. */
     resolveConflict(id, resolution) {
         const now = new Date().toISOString();
-        const record = this.db.prepare('SELECT status FROM projection_outbox WHERE id=?').get(id);
+        const record = this.db.prepare(`SELECT status FROM projection_outbox WHERE id=?${this.scopeAnd}`).get(...this.bind(id));
         if (!record || record.status !== 'conflict')
             return false;
         const resolutionJson = JSON.stringify({ action: resolution.action, resolvedAt: now, ...(resolution.note ? { note: resolution.note } : {}) });
@@ -295,11 +320,11 @@ export class ProjectionOutbox {
         UPDATE projection_outbox
         SET status='pending', attempts=0, next_attempt_at=NULL, conflict_disposition='requeued',
             conflict_resolution_json=?, updated_at=?
-        WHERE id=? AND status='conflict'
-      `).run(resolutionJson, now, id);
+        WHERE id=? AND status='conflict'${this.scopeAnd}
+      `).run(...this.bind(resolutionJson, now, id));
         }
         else {
-            this.db.prepare('DELETE FROM projection_outbox WHERE id=? AND status=?').run(id, 'conflict');
+            this.db.prepare(`DELETE FROM projection_outbox WHERE id=? AND status=?${this.scopeAnd}`).run(...this.bind(id, 'conflict'));
         }
         return true;
     }
@@ -307,7 +332,7 @@ export class ProjectionOutbox {
     pendingCount() { return this.count("status IN ('pending','processing')"); }
     terminalCount() { return this.count("status='dead'"); }
     count(where) {
-        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM projection_outbox WHERE ${where}`).get();
+        const row = this.db.prepare(`SELECT COUNT(*) AS count FROM projection_outbox WHERE ${where}${this.scopeAnd}`).get(...(this.scopeJobId ? [this.scopeJobId] : []));
         return Number(row?.count ?? 0);
     }
 }

package/dist/relay-store-discovery.js

@@ -0,0 +1,93 @@
+import { DatabaseSync } from 'node:sqlite';
+import { dirname, join } from 'node:path';
+import { readdir } from 'node:fs/promises';
+import { normalizeLegacyJobPrNumber } from './job-pr-number-migration.js';
+/** Unified mode must be opted into only after the complete offline migration passes. */
+export function unifiedRelayStoreEnabled(env = process.env) {
+    return env.AGENTS_RELAY_SQLITE_MODE === 'unified';
+}
+export function relayUnifiedStorePath(directory) { return join(dirname(directory), 'relay.sqlite'); }
+/** Resolve one Job scope by repository and PR, refusing ambiguous matches. */
+export function resolveUnifiedJobScope(directory, repository, prNumber, hintId) {
+    const db = new DatabaseSync(relayUnifiedStorePath(directory), { readOnly: true });
+    try {
+        if (hintId) {
+            const binding = db.prepare('SELECT repository,pr_number FROM source_registry WHERE job_id=?').get(hintId);
+            if (binding && (binding.repository !== repository || (prNumber > 0 && binding.pr_number !== prNumber)))
+                throw new Error(`Job ${hintId} is bound to another repository or PR`);
+            return hintId;
+        }
+        const rows = db.prepare('SELECT job_id FROM source_registry WHERE repository=? AND pr_number=?').all(repository, prNumber);
+        if (rows.length !== 1)
+            throw new Error(`Unified Job scope is ${rows.length ? 'ambiguous' : 'missing'} for ${repository} PR ${prNumber}; supply immutable Job ID`);
+        return rows[0].job_id;
+    }
+    finally {
+        db.close();
+    }
+}
+/** Canonical on-disk Relay Store location for one managed GitHub pull request. */
+export function relayStorePath(directory, repository, prNumber) {
+    return directory + '/' + `${repository.replace('/', '_')}-${prNumber}.db`;
+}
+/**
+ * SQLite is the only job registry. Inventory queries must be strictly read-only:
+ * opening a writable RelayStore here would reset in-flight projection claims
+ * on every dashboard refresh and could replay external merge side effects.
+ */
+export async function discoverLocalRelayStoreSnapshots(directory) {
+    if (unifiedRelayStoreEnabled()) {
+        const path = relayUnifiedStorePath(directory);
+        const db = new DatabaseSync(path, { readOnly: true });
+        try {
+            const snapshots = [];
+            const rows = db.prepare('SELECT json FROM job_snapshot ORDER BY CAST(job_id AS INTEGER)').all();
+            const allPublications = Object.fromEntries(db.prepare('SELECT job_id,json FROM publication_state').all().map(row => [row.job_id, JSON.parse(row.json)]));
+            for (const row of rows) {
+                const job = normalizeLegacyJobPrNumber(JSON.parse(row.json));
+                const fact = db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE scope_job_id=? AND id=1').get(job.id);
+                const facts = fact ? { state: fact.state, head: fact.head_ref && fact.head_sha ? { ref: fact.head_ref, sha: fact.head_sha } : null, observedAt: fact.observed_at } : null;
+                const publications = {};
+                if (allPublications[job.id])
+                    publications[job.id] = allPublications[job.id];
+                snapshots.push({ path, jobs: [job], facts, publications });
+            }
+            return snapshots;
+        }
+        finally {
+            db.close();
+        }
+    }
+    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 db;
+        try {
+            db = new DatabaseSync(path, { readOnly: true });
+            const rows = db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
+            const jobs = rows.map(row => normalizeLegacyJobPrNumber(JSON.parse(row.json)));
+            const row = db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get();
+            const facts = row ? {
+                state: row.state,
+                head: row.head_ref && row.head_sha ? { ref: row.head_ref, sha: row.head_sha } : null,
+                observedAt: row.observed_at,
+            } : null;
+            const publications = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='publication_state'").get() ? Object.fromEntries(db.prepare('SELECT job_id,json FROM publication_state').all().map(item => [item.job_id, JSON.parse(item.json)])) : {};
+            snapshots.push({ path, jobs, facts, publications });
+        }
+        catch {
+            // Ignore unrelated/corrupt files without allowing one damaged store to block recovery.
+        }
+        finally {
+            db?.close();
+        }
+    }
+    return snapshots;
+}

package/dist/relay-store.js

@@ -2,10 +2,11 @@ import { preserveTaskComments } from './task-comments.js';
 import { DatabaseSync } from 'node:sqlite';
 import { dirname } from 'node:path';
 import { mkdirSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
 import { recordPublicationInDatabase, loadPublicationFromDatabase, listPublicationEventsFromDatabase } from './publication-store.js';
 import { observability } from './observability.js';
 import { createJobIfAbsent } from './relay-create.js';
+import { ensureUnifiedJobRegistry, createUnifiedJobIfAbsent } from './unified-job-registry.js';
+import { saveUnifiedPullRequestFacts } from './unified-pr-facts.js';
 import { migrateLegacyJobPrNumbers, normalizeLegacyJobPrNumber } from './job-pr-number-migration.js';
 import { hostInvocationTablesSql, recordHostInvocationEvent, hasHostInvocationDecision, recordHostInvocationDecision } from './host-invocation-store.js';
 import { ProjectionOutbox, SCHEMA_VERSION, logicalOperationKey, } from './projection-outbox.js';
@@ -44,18 +45,30 @@ function monotonicJobTimestamp(previous, candidate = new Date().toISOString()) {
 }
 export class SQLiteRelayStore {
     path;
+    scopeJobId;
     db;
     outbox;
-    constructor(path) {
+    constructor(path, scopeJobId) {
         this.path = path;
+        this.scopeJobId = scopeJobId;
         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.outbox = new ProjectionOutbox(this.db);
+        if (scopeJobId) {
+            const schema = this.db.prepare("SELECT value FROM migration_metadata WHERE key='schema'").get();
+            if (schema?.value !== 'single-sqlite-staging-v1')
+                throw new Error('Unified Relay schema is missing or unsupported');
+        }
+        else
+            this.migrate();
+        this.outbox = new ProjectionOutbox(this.db, scopeJobId);
         this.outbox.resetProcessing(new Date().toISOString());
     }
+    assertScope(jobId) {
+        if (this.scopeJobId && jobId !== this.scopeJobId)
+            throw new Error(`Wrong scoped Job ID ${jobId}; expected ${this.scopeJobId}`);
+    }
     migrate() {
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS relay_meta (
@@ -125,21 +138,38 @@ export class SQLiteRelayStore {
         return listPublicationEventsFromDatabase(this.db, jobId);
     }
     async loadJob(jobId) {
+        this.assertScope(jobId);
         const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
         return row?.json ? normalizeLegacyJobPrNumber(JSON.parse(row.json)) : null;
     }
     async listJobs() {
-        const rows = this.db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
+        const rows = this.db.prepare(this.scopeJobId ? 'SELECT json FROM job_snapshot WHERE job_id=? ORDER BY job_id' : 'SELECT json FROM job_snapshot ORDER BY job_id').all(...(this.scopeJobId ? [this.scopeJobId] : []));
         return rows.map(row => normalizeLegacyJobPrNumber(JSON.parse(row.json)));
     }
     async saveJob(job) {
-        this.writeJobSnapshot(job, new Date().toISOString());
+        if (!this.scopeJobId) {
+            this.writeJobSnapshot(job, new Date().toISOString());
+            return;
+        }
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.writeJobSnapshot(job, new Date().toISOString());
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
     }
     async createJobIfAbsent(job) {
-        return createJobIfAbsent(this.db, job);
+        this.assertScope(job.id);
+        return this.scopeJobId
+            ? createUnifiedJobIfAbsent(this.db, job, now => this.writeJobSnapshot(job, now))
+            : createJobIfAbsent(this.db, job);
     }
     /** Atomic read/modify/write for local authoritative Task and Plan updates. */
     async mutateJob(jobId, mutation) {
+        this.assertScope(jobId);
         this.db.exec('BEGIN IMMEDIATE');
         try {
             const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
@@ -163,6 +193,7 @@ export class SQLiteRelayStore {
         }
     }
     async ingestJobSnapshot(job) {
+        this.assertScope(job.id);
         const now = new Date().toISOString();
         this.db.exec('BEGIN IMMEDIATE');
         try {
@@ -179,6 +210,7 @@ export class SQLiteRelayStore {
         }
     }
     async saveJobWithProjection(job, request) {
+        this.assertScope(job.id);
         const now = new Date().toISOString();
         this.db.exec('BEGIN IMMEDIATE');
         try {
@@ -200,26 +232,38 @@ export class SQLiteRelayStore {
         }
     }
     writeJobSnapshot(job, now) {
+        if (this.scopeJobId)
+            ensureUnifiedJobRegistry(this.db, job, this.scopeJobId);
         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();
+        const observed = this.scopeJobId
+            ? this.db.prepare("SELECT value FROM relay_meta WHERE scope_job_id=? AND key='agent_registry_observed_at'").get(this.scopeJobId)
+            : 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();
+        const rows = this.db.prepare(this.scopeJobId ? 'SELECT json FROM agent_snapshot WHERE scope_job_id=? ORDER BY agent_id' : 'SELECT json FROM agent_snapshot ORDER BY agent_id').all(...(this.scopeJobId ? [this.scopeJobId] : []));
         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);
+            if (this.scopeJobId) {
+                this.db.prepare('DELETE FROM agent_snapshot WHERE scope_job_id=?').run(this.scopeJobId);
+                const insert = this.db.prepare('INSERT INTO agent_snapshot(scope_job_id,agent_id,json,updated_at) VALUES(?,?,?,?)');
+                for (const agent of agents)
+                    insert.run(this.scopeJobId, agent.id, JSON.stringify(agent), now);
+            }
+            else {
+                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');
         }
@@ -256,19 +300,29 @@ export class SQLiteRelayStore {
         }
     }
     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);
+        if (this.scopeJobId) {
+            this.db.prepare(`INSERT INTO agent_snapshot(scope_job_id,agent_id,json,updated_at) VALUES(?,?,?,?)
+        ON CONFLICT(scope_job_id,agent_id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at`)
+                .run(this.scopeJobId, agent.id, JSON.stringify(agent), now);
+        }
+        else {
+            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);
+        if (this.scopeJobId) {
+            this.db.prepare(`INSERT INTO relay_meta(scope_job_id,key,value) VALUES(?,'agent_registry_observed_at',?)
+        ON CONFLICT(scope_job_id,key) DO UPDATE SET value=excluded.value`).run(this.scopeJobId, now);
+        }
+        else {
+            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();
+        const row = this.db.prepare(this.scopeJobId ? 'SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE scope_job_id=? AND id=1' : 'SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get(...(this.scopeJobId ? [this.scopeJobId] : []));
         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 };
@@ -277,7 +331,11 @@ export class SQLiteRelayStore {
         // UNKNOWN means absence of confirmed external evidence; never persist it as a fact.
         if (facts.state === 'UNKNOWN')
             return;
-        this.db.prepare(`
+        if (this.scopeJobId) {
+            saveUnifiedPullRequestFacts(this.db, this.scopeJobId, facts);
+        }
+        else {
+            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
       WHERE excluded.observed_at >= pull_request_facts.observed_at
@@ -285,6 +343,7 @@ export class SQLiteRelayStore {
           OR (pull_request_facts.state='CLOSED' AND excluded.state IN ('CLOSED','MERGED'))
           OR (pull_request_facts.state='MERGED' AND excluded.state='MERGED'))
     `).run(facts.state, facts.head?.ref ?? null, facts.head?.sha ?? null, facts.observedAt);
+        }
     }
     async recordExecutionProcess(record) {
         const existing = await this.loadExecutionProcess(record.jobId, record.taskId, record.executionId);
@@ -316,9 +375,11 @@ export class SQLiteRelayStore {
         return recordHostInvocationDecision(this.db, delivery, fingerprint, (job, at) => this.writeJobSnapshot(job, at));
     }
     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());
+        const result = this.scopeJobId
+            ? this.db.prepare('INSERT OR IGNORE INTO event_receipt(scope_job_id,event_id,stream,sequence,received_at) VALUES(?,?,?,?,?)')
+                .run(this.scopeJobId, eventId, stream, sequence, new Date().toISOString())
+            : 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;
     }
     enqueueProjectionInTransaction(request, now) {
@@ -354,7 +415,11 @@ export class SQLiteRelayStore {
         const key = logicalOperationKey(request.idempotencyKey);
         this.db.exec('BEGIN IMMEDIATE');
         try {
-            const existing = this.db.prepare('SELECT id FROM projection_outbox WHERE operation_key=? LIMIT 1').get(key) ?? this.db.prepare('SELECT operation_key FROM projection_receipt WHERE operation_key=?').get(key);
+            const existing = this.scopeJobId
+                ? (this.db.prepare('SELECT id FROM projection_outbox WHERE scope_job_id=? AND operation_key=? LIMIT 1').get(this.scopeJobId, key)
+                    ?? this.db.prepare('SELECT operation_key FROM projection_receipt WHERE scope_job_id=? AND operation_key=?').get(this.scopeJobId, key))
+                : (this.db.prepare('SELECT id FROM projection_outbox WHERE operation_key=? LIMIT 1').get(key)
+                    ?? this.db.prepare('SELECT operation_key FROM projection_receipt WHERE operation_key=?').get(key));
             if (existing) {
                 this.db.exec('COMMIT');
                 return false;
@@ -389,47 +454,5 @@ export class SQLiteRelayStore {
     async recordProjectionReceipt(operationKey, status, attempts, detail) { this.outbox.recordReceipt(operationKey, status, attempts, detail, new Date().toISOString()); }
     close() { this.db.close(); }
 }
-/** Canonical on-disk Relay Store location for one managed GitHub pull request. */
-export function relayStorePath(directory, repository, prNumber) {
-    return directory + '/' + `${repository.replace('/', '_')}-${prNumber}.db`;
-}
 export { relayJobStorePath, relayStoreDirectory } from './local-job-path.js';
-/**
- * SQLite is the only job registry. Inventory queries must be strictly read-only:
- * opening a writable RelayStore here would reset in-flight projection claims
- * on every dashboard refresh and could replay external merge side effects.
- */
-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 db;
-        try {
-            db = new DatabaseSync(path, { readOnly: true });
-            const rows = db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
-            const jobs = rows.map(row => normalizeLegacyJobPrNumber(JSON.parse(row.json)));
-            const row = db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get();
-            const facts = row ? {
-                state: row.state,
-                head: row.head_ref && row.head_sha ? { ref: row.head_ref, sha: row.head_sha } : null,
-                observedAt: row.observed_at,
-            } : null;
-            const publications = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='publication_state'").get() ? Object.fromEntries(db.prepare('SELECT job_id,json FROM publication_state').all().map(item => [item.job_id, JSON.parse(item.json)])) : {};
-            snapshots.push({ path, jobs, facts, publications });
-        }
-        catch {
-            // Ignore unrelated/corrupt files without allowing one damaged store to block recovery.
-        }
-        finally {
-            db?.close();
-        }
-    }
-    return snapshots;
-}
+export { unifiedRelayStoreEnabled, relayUnifiedStorePath, resolveUnifiedJobScope, relayStorePath, discoverLocalRelayStoreSnapshots } from './relay-store-discovery.js';

package/dist/relayd-control.js

@@ -4,7 +4,7 @@ import { openLocalManagedStore } from './local-managed-store.js';
 import { relayStoreDirectory } from './relay-store.js';
 import { normalizeThreadId } from './reviewer-thread.js';
 import { supersedeCancelledTask } from './task-actions.js';
-import { adoptLegacyJob } from './cli-job-create.js';
+import { adoptExistingPullRequestJob } from './cli-job-create.js';
 export function createWorkspaceControl(deps) {
     const { client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, unblockAutonomousTasks, unblockTask, publishTaskUnblocked, dispatchTaskAction, registerBlockerDependency, discoverAgents, ensureManagedGitHubJob } = deps;
     const workspaceControl = async (body) => {
@@ -69,10 +69,10 @@ export function createWorkspaceControl(deps) {
         if (command === 'job.adopt') {
             const repository = typeof body.repository === 'string' ? body.repository : '';
             const options = (body.options && typeof body.options === 'object' ? body.options : {});
-            if (!repository || typeof options.id !== 'string' || typeof options.prNumber !== 'number')
-                throw new Error('job.adopt requires repository, id, and prNumber');
-            const result = await adoptLegacyJob(client, repository, trusted, {
-                id: options.id, title: typeof options.title === 'string' ? options.title : undefined,
+            if (!repository || typeof options.prNumber !== 'number')
+                throw new Error('job.adopt requires repository and prNumber');
+            const result = await adoptExistingPullRequestJob(client, repository, trusted, {
+                id: typeof options.id === 'string' ? options.id : undefined, title: typeof options.title === 'string' ? options.title : undefined,
                 objective: typeof options.objective === 'string' ? options.objective : undefined,
                 projectPath: typeof options.projectPath === 'string' ? options.projectPath : undefined,
                 prNumber: options.prNumber,

package/dist/relayd.js

@@ -4,7 +4,7 @@ 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 { join, basename } from 'node:path';
 import { ChatGptAdapter, CodexAdapter, ensureChatGptBrowserWorkspace } from './adapters.js';
 import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
 import { serveDashboard } from './dashboard.js';
@@ -13,7 +13,7 @@ import { Reconciler } from './reconciler.js';
 import { dashboardManagedJobs, GitHubStore, InMemoryStore, resolvePullRequest } from './store.js';
 import { GitHubProjectionWriter } from './projected-store.js';
 import { LocalAuthorityDurableStore } from './local-authority-store.js';
-import { discoverLocalRelayStoreSnapshots, relayStoreDirectory, relayStorePath, SQLiteRelayStore } from './relay-store.js';
+import { discoverLocalRelayStoreSnapshots, relayStoreDirectory, relayStorePath, relayUnifiedStorePath, unifiedRelayStoreEnabled, resolveUnifiedJobScope, 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';
@@ -22,7 +22,6 @@ import { ProjectionFailureDeduplicator } from './projection-failure-dedupe.js';
 import { authoritativeBranchPushArgs } from './github-branch-projection.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, publishTaskUnblocked, resolveEventBus } from './cli-support.js';
 import { eventFor } from './events.js';
@@ -117,7 +116,8 @@ export async function runDaemon(argv) {
         const key = `${repository}#${prNumber}`;
         let relay = relayStores.get(key);
         if (!relay) {
-            relay = new SQLiteRelayStore(relayStorePath(relayStoreDirectory(), repository, prNumber));
+            const scope = unifiedRelayStoreEnabled() ? resolveUnifiedJobScope(relayStoreDirectory(), repository, prNumber) : undefined;
+            relay = new SQLiteRelayStore(scope ? relayUnifiedStorePath(relayStoreDirectory()) : relayStorePath(relayStoreDirectory(), repository, prNumber), scope);
             relayStores.set(key, relay);
         }
         const github = new GitHubStore(client, repository, prNumber, trusted, seed);
@@ -127,7 +127,6 @@ export async function runDaemon(argv) {
             projectionWriters.set(key, projected.projection);
         return projected;
     };
-    // SQLite inventory, not GitHub discovery, defines which repositories exist.
     const existingInventory = await discoverLocalRelayStoreSnapshots(relayStoreDirectory());
     for (const snapshot of existingInventory)
         for (const job of snapshot.jobs) {
@@ -230,10 +229,11 @@ export async function runDaemon(argv) {
                 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);
+                const scopedKey = unifiedRelayStoreEnabled() ? `${snapshot.path}#${discovered.id}` : snapshot.path;
+                let relay = relayStores.get(scopedKey);
                 if (!relay) {
-                    relay = new SQLiteRelayStore(snapshot.path);
-                    relayStores.set(snapshot.path, relay);
+                    relay = new SQLiteRelayStore(snapshot.path, unifiedRelayStoreEnabled() ? discovered.id : undefined);
+                    relayStores.set(scopedKey, 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

package/dist/service-publication.js

@@ -1,10 +1,10 @@
 import { eventFor } from './events.js';
-import { SQLiteRelayStore, relayStoreDirectory, relayStorePath } from './relay-store.js';
+import { SQLiteRelayStore, relayStoreDirectory, relayStorePath, relayUnifiedStorePath, unifiedRelayStoreEnabled } from './relay-store.js';
 /** Single-Job service uses the same durable publish facts as the repository daemon. */
 export async function handleServicePublication(job, wake, bus, directory = relayStoreDirectory()) {
     if (!wake.publication && !wake.publishFailure)
         return;
-    const sqlite = new SQLiteRelayStore(relayStorePath(directory, job.repository, job.prNumber));
+    const sqlite = new SQLiteRelayStore(unifiedRelayStoreEnabled() ? relayUnifiedStorePath(directory) : relayStorePath(directory, job.repository, job.prNumber), unifiedRelayStoreEnabled() ? job.id : undefined);
     try {
         await sqlite.recordPublication(job.id, wake.deliveryId, wake.publication, wake.publishFailure ?? null, wake.publicationObservedAt);
     }

package/dist/unified-job-registry.js

@@ -0,0 +1,33 @@
+/** Enforce immutable Job-to-repository identity; PR number may bind once from 0. */
+export function ensureUnifiedJobRegistry(db, job, expectedJobId) {
+    if (job.id !== expectedJobId)
+        throw new Error(`Wrong scoped Job ID ${job.id}; expected ${expectedJobId}`);
+    db.prepare('INSERT INTO source_registry(job_id,source_file,repository,pr_number) VALUES(?,?,?,?) ON CONFLICT(job_id) DO NOTHING')
+        .run(job.id, `unified:${job.id}`, job.repository, job.prNumber);
+    const binding = db.prepare('SELECT repository,pr_number FROM source_registry WHERE job_id=?')
+        .get(job.id);
+    if (binding?.repository !== job.repository || !Number.isInteger(binding.pr_number))
+        throw new Error(`Job ${job.id} has conflicting repository identity`);
+    if (binding.pr_number > 0 && job.prNumber !== binding.pr_number)
+        throw new Error(`Job ${job.id} cannot change an established PR binding`);
+    if (binding.pr_number === 0 && job.prNumber > 0)
+        db.prepare('UPDATE source_registry SET pr_number=? WHERE job_id=? AND pr_number=0').run(job.prNumber, job.id);
+}
+/** Preserve atomic create-if-absent across all Job scopes in the single SQLite. */
+export function createUnifiedJobIfAbsent(db, job, writeSnapshot) {
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const existing = db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(job.id);
+        if (existing?.json) {
+            db.exec('COMMIT');
+            return JSON.parse(existing.json);
+        }
+        writeSnapshot(new Date().toISOString());
+        db.exec('COMMIT');
+        return structuredClone(job);
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}

package/dist/unified-pr-facts.js

@@ -0,0 +1,11 @@
+/** Job-scoped PR projection facts; never conflate the historic singleton id=1. */
+export function saveUnifiedPullRequestFacts(db, jobId, facts) {
+    db.prepare(`INSERT INTO pull_request_facts(scope_job_id,id,state,head_ref,head_sha,observed_at) VALUES(?,1,?,?,?,?)
+    ON CONFLICT(scope_job_id,id) DO UPDATE SET state=excluded.state,head_ref=excluded.head_ref,
+      head_sha=excluded.head_sha,observed_at=excluded.observed_at
+    WHERE excluded.observed_at >= pull_request_facts.observed_at
+      AND (pull_request_facts.state='OPEN'
+        OR (pull_request_facts.state='CLOSED' AND excluded.state IN ('CLOSED','MERGED'))
+        OR (pull_request_facts.state='MERGED' AND excluded.state='MERGED'))`)
+        .run(jobId, facts.state, facts.head?.ref ?? null, facts.head?.sha ?? null, facts.observedAt);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.97",
+  "version": "2.0.99",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {