agents-relay 2.0.109 → 2.0.110

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

@@ -1,6 +1,6 @@
 import { DatabaseSync } from 'node:sqlite';
 import { mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { relayUnifiedStorePath } from './relay-store-discovery.js';
 function validateRepository(repository) {
     const [owner, repo, extra] = repository.split('/');
     if (!owner || !repo || extra || !/^[\w.-]+$/.test(owner) || !/^[\w.-]+$/.test(repo) || owner === '..' || repo === '..')
@@ -19,7 +19,7 @@ export function allocateEntityId(directory, repository, kind, requestKey, occupi
     if (requestKey !== undefined && (!requestKey || requestKey.length > 512))
         throw new Error('Invalid idempotency key');
     mkdirSync(directory, { recursive: true });
-    const db = new DatabaseSync(process.env.AGENTS_RELAY_SQLITE_MODE === 'unified' ? join(dirname(directory), 'relay.sqlite') : join(directory, 'entity-id-sequences.sqlite'));
+    const db = new DatabaseSync(relayUnifiedStorePath(directory));
     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-path.js

@@ -1,12 +1,5 @@
-import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-/** Primary local store key is immutable Job ID, independent of a PR number. */
-export function relayJobStorePath(directory, jobId) {
-    if (!jobId.trim() || jobId.length > 1024)
-        throw new Error('Invalid immutable Job ID');
-    return directory + '/job-' + createHash('sha256').update(jobId).digest('hex') + '.db';
-}
 export function relayStoreDirectory(env = process.env) {
     return env.AGENTS_RELAY_STORE_DIR || join(homedir(), '.agents-relay', 'stores');
 }

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, unifiedRelayStoreEnabled, SQLiteRelayStore } from './relay-store.js';
+import { discoverLocalRelayStoreSnapshots, 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,10 @@ export function createJobIdRegistryResolver(directory, openStores, options = {})
         if (!selected)
             return null;
         const { snapshot, job } = selected;
-        const scopedKey = unifiedRelayStoreEnabled() ? `${snapshot.path}#${job.id}` : snapshot.path;
+        const scopedKey = `${snapshot.path}#${job.id}`;
         let relay = openStores.get(scopedKey);
         if (!relay) {
-            relay = new SQLiteRelayStore(snapshot.path, unifiedRelayStoreEnabled() ? job.id : undefined);
+            relay = new SQLiteRelayStore(snapshot.path, job.id);
             openStores.set(scopedKey, relay);
         }
         // SQLite remains lifecycle authority. A positive PR binding only enables

package/dist/local-managed-store.js

@@ -2,16 +2,16 @@ 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, relayUnifiedStorePath, unifiedRelayStoreEnabled, resolveUnifiedJobScope, SQLiteRelayStore } from './relay-store.js';
+import { relayStoreDirectory, relayUnifiedStorePath, 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 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 path = relayUnifiedStorePath(directory);
+    const scope = resolveUnifiedJobScope(directory, repository, prNumber, options.jobId);
+    const relay = new SQLiteRelayStore(path, 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 {

package/dist/relay-store-discovery.js

@@ -1,16 +1,22 @@
 import { DatabaseSync } from 'node:sqlite';
-import { dirname, join } from 'node:path';
 import { readdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
 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 });
+    const path = relayUnifiedStorePath(directory);
+    if (hintId && !existsSync(path))
+        return hintId;
+    const db = new DatabaseSync(path, { readOnly: true });
     try {
+        const hasRegistry = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='source_registry'").get();
+        if (!hasRegistry) {
+            if (hintId)
+                return hintId;
+            throw new Error(`Unified Job scope is missing for ${repository} PR ${prNumber}; supply immutable Job ID`);
+        }
         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)))
@@ -26,68 +32,39 @@ export function resolveUnifiedJobScope(directory, repository, prNumber, hintId)
         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();
+    const path = relayUnifiedStorePath(directory);
+    if (!existsSync(path)) {
+        // Never silently treat legacy per-Job files as an empty authoritative database.
+        const files = await readdir(directory).catch(error => {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        });
+        if (files.some(name => name.endsWith('.db'))) {
+            throw new Error(`Unified Relay SQLite database missing at ${path}; legacy Job databases exist in ${directory}`);
         }
+        return [];
     }
-    let names;
+    const db = new DatabaseSync(path, { readOnly: true });
     try {
-        names = await readdir(directory);
+        const rows = db.prepare('SELECT json FROM job_snapshot ORDER BY CAST(job_id AS INTEGER), job_id').all();
+        const allPublications = Object.fromEntries(db.prepare('SELECT job_id,json FROM publication_state').all().map(row => [row.job_id, JSON.parse(row.json)]));
+        return rows.map(row => {
+            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);
+            return { path, jobs: [job], 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, publications: allPublications[job.id] ? { [job.id]: allPublications[job.id] } : {} };
+        });
     }
-    catch {
-        return [];
+    catch (error) {
+        throw new Error(`Unified Relay SQLite inventory unreadable at ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
-    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();
-        }
+    finally {
+        db.close();
     }
-    return snapshots;
 }

package/dist/relay-store.js

@@ -7,6 +7,7 @@ import { recordPublicationInDatabase, loadPublicationFromDatabase, listPublicati
 import { observability } from './observability.js';
 import { createJobIfAbsent } from './relay-create.js';
 import { ensureUnifiedJobRegistry, createUnifiedJobIfAbsent } from './unified-job-registry.js';
+import { migrateUnifiedRelaySchema } from './unified-relay-schema.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';
@@ -57,9 +58,14 @@ export class SQLiteRelayStore {
         this.db = new DatabaseSync(path);
         this.db.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA busy_timeout=5000; PRAGMA foreign_keys=ON;');
         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');
+            const hasUnifiedSchema = this.db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='migration_metadata'").get();
+            if (!hasUnifiedSchema)
+                migrateUnifiedRelaySchema(this.db);
+            else {
+                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();
@@ -460,5 +466,5 @@ export class SQLiteRelayStore {
     async recordProjectionReceipt(operationKey, status, attempts, detail) { this.outbox.recordReceipt(operationKey, status, attempts, detail, new Date().toISOString()); }
     close() { this.db.close(); }
 }
-export { relayJobStorePath, relayStoreDirectory } from './local-job-path.js';
-export { unifiedRelayStoreEnabled, relayUnifiedStorePath, resolveUnifiedJobScope, relayStorePath, discoverLocalRelayStoreSnapshots } from './relay-store-discovery.js';
+export { relayStoreDirectory } from './local-job-path.js';
+export { relayUnifiedStorePath, resolveUnifiedJobScope, discoverLocalRelayStoreSnapshots } from './relay-store-discovery.js';

package/dist/relayd.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, relayUnifiedStorePath, unifiedRelayStoreEnabled, resolveUnifiedJobScope, SQLiteRelayStore } from './relay-store.js';
+import { discoverLocalRelayStoreSnapshots, relayStoreDirectory, relayUnifiedStorePath, 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';
@@ -116,8 +116,8 @@ export async function runDaemon(argv) {
         const key = `${repository}#${prNumber}`;
         let relay = relayStores.get(key);
         if (!relay) {
-            const scope = unifiedRelayStoreEnabled() ? resolveUnifiedJobScope(relayStoreDirectory(), repository, prNumber) : undefined;
-            relay = new SQLiteRelayStore(scope ? relayUnifiedStorePath(relayStoreDirectory()) : relayStorePath(relayStoreDirectory(), repository, prNumber), scope);
+            const scope = resolveUnifiedJobScope(relayStoreDirectory(), repository, prNumber);
+            relay = new SQLiteRelayStore(relayUnifiedStorePath(relayStoreDirectory()), scope);
             relayStores.set(key, relay);
         }
         const github = new GitHubStore(client, repository, prNumber, trusted, seed);
@@ -229,10 +229,10 @@ 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);
-                const scopedKey = unifiedRelayStoreEnabled() ? `${snapshot.path}#${discovered.id}` : snapshot.path;
+                const scopedKey = `${snapshot.path}#${discovered.id}`;
                 let relay = relayStores.get(scopedKey);
                 if (!relay) {
-                    relay = new SQLiteRelayStore(snapshot.path, unifiedRelayStoreEnabled() ? discovered.id : undefined);
+                    relay = new SQLiteRelayStore(snapshot.path, discovered.id);
                     relayStores.set(scopedKey, relay);
                 }
                 const canonical = repositoryPaths.get(discovered.repository) ?? await resolveManagedProjectPath(discovered.repository, explicitProjectPath, workspaceRoot);

package/dist/service-publication.js

@@ -1,10 +1,10 @@
 import { eventFor } from './events.js';
-import { SQLiteRelayStore, relayStoreDirectory, relayStorePath, relayUnifiedStorePath, unifiedRelayStoreEnabled } from './relay-store.js';
+import { SQLiteRelayStore, relayStoreDirectory, relayUnifiedStorePath } 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(unifiedRelayStoreEnabled() ? relayUnifiedStorePath(directory) : relayStorePath(directory, job.repository, job.prNumber), unifiedRelayStoreEnabled() ? job.id : undefined);
+    const sqlite = new SQLiteRelayStore(relayUnifiedStorePath(directory), job.id);
     try {
         await sqlite.recordPublication(job.id, wake.deliveryId, wake.publication, wake.publishFailure ?? null, wake.publicationObservedAt);
     }

package/dist/unified-relay-schema.js

@@ -0,0 +1,26 @@
+import { hostInvocationTablesSql } from './host-invocation-store.js';
+/** Bootstrap the single authoritative Relay SQLite schema. */
+export function migrateUnifiedRelaySchema(db) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS source_registry (job_id TEXT PRIMARY KEY, source_file TEXT NOT NULL UNIQUE, repository TEXT NOT NULL, pr_number INTEGER NOT NULL);
+      CREATE INDEX IF NOT EXISTS source_registry_repo_pr ON source_registry(repository,pr_number);
+      CREATE TABLE IF NOT EXISTS migration_metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS relay_meta (scope_job_id TEXT NOT NULL REFERENCES source_registry(job_id), key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY(scope_job_id,key));
+      CREATE TABLE IF NOT EXISTS job_snapshot (job_id TEXT PRIMARY KEY, json TEXT NOT NULL, updated_at TEXT NOT NULL);
+      CREATE INDEX IF NOT EXISTS job_snapshot_updated ON job_snapshot(updated_at);
+      CREATE TABLE IF NOT EXISTS pull_request_facts (scope_job_id TEXT NOT NULL REFERENCES source_registry(job_id), id INTEGER NOT NULL CHECK(id=1), state TEXT NOT NULL CHECK(state IN ('OPEN','MERGED','CLOSED')), head_ref TEXT, head_sha TEXT, observed_at TEXT NOT NULL, PRIMARY KEY(scope_job_id,id));
+      CREATE TABLE IF NOT EXISTS publication_state (job_id TEXT PRIMARY KEY, json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS publication_delivery (job_id TEXT NOT NULL, delivery_id TEXT NOT NULL, type TEXT NOT NULL, json TEXT NOT NULL, observed_at TEXT NOT NULL, PRIMARY KEY(job_id,delivery_id));
+      CREATE TABLE IF NOT EXISTS agent_snapshot (scope_job_id TEXT NOT NULL REFERENCES source_registry(job_id), agent_id TEXT NOT NULL, json TEXT NOT NULL, updated_at TEXT NOT NULL, PRIMARY KEY(scope_job_id,agent_id));
+      CREATE TABLE IF NOT EXISTS event_receipt (scope_job_id TEXT NOT NULL REFERENCES source_registry(job_id), event_id TEXT NOT NULL, stream TEXT, sequence INTEGER, received_at TEXT NOT NULL, PRIMARY KEY(scope_job_id,event_id));
+      CREATE TABLE IF NOT EXISTS execution_process (job_id TEXT NOT NULL, task_id TEXT NOT NULL, execution_id TEXT NOT NULL, lease_owner TEXT NOT NULL, host TEXT NOT NULL, pid INTEGER NOT NULL, pgid INTEGER NOT NULL, start_token TEXT NOT NULL, observed_at TEXT NOT NULL, ended_at TEXT, PRIMARY KEY(job_id,task_id,execution_id));
+      ${hostInvocationTablesSql}
+      CREATE TABLE IF NOT EXISTS projection_outbox (scope_job_id TEXT NOT NULL REFERENCES source_registry(job_id), id INTEGER NOT NULL, idempotency_key TEXT NOT NULL, operation_key TEXT, 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','conflict','dead')), attempts INTEGER NOT NULL DEFAULT 0, next_attempt_at TEXT, last_error TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, conflict_definition_json TEXT, conflict_evidence_json TEXT, conflict_detected_at TEXT, conflict_disposition TEXT, conflict_resolution_json TEXT, PRIMARY KEY(scope_job_id,id), UNIQUE(scope_job_id,idempotency_key));
+      CREATE INDEX IF NOT EXISTS projection_unified_due ON projection_outbox(scope_job_id,status,next_attempt_at,priority DESC,id);
+      CREATE INDEX IF NOT EXISTS projection_unified_coalesce ON projection_outbox(scope_job_id,coalesce_key,status);
+      CREATE TABLE IF NOT EXISTS projection_receipt (scope_job_id TEXT NOT NULL REFERENCES source_registry(job_id), operation_key TEXT NOT NULL, status TEXT NOT NULL CHECK(status IN ('succeeded','failed')), attempts INTEGER NOT NULL, detail_json TEXT, recorded_at TEXT NOT NULL, PRIMARY KEY(scope_job_id,operation_key));
+      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));
+      INSERT INTO migration_metadata(key,value) VALUES('schema','single-sqlite-staging-v1'),('job_count','0');
+    `);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.109",
+  "version": "2.0.110",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",