agents-relay 2.0.66 → 2.0.68

package/README.md

@@ -1,8 +1,9 @@
 # Agents Relay
 
-Agents Relay is a generic TypeScript runtime for durable asynchronous agent jobs coordinated through GitHub pull requests. The PR body stores the durable Job marker plus human-readable Job objective, while PR comments store durable Task and other append-friendly records; correlated terminal events are authoritative for model-backed task lifecycle transitions.
+Agents Relay is a TypeScript runtime for durable asynchronous agent Jobs driven locally by SQLite and canonical workflow Graphs. The EventBus wakes reconciliation; an EventBus message or GitHub PR comment is never the lifecycle authority. Job, Plan, Task, Review, Execution, Lease and Recovery state survive daemon restarts in SQLite.
+
+V2 uses a read-only local SQLite Job Registry for discovery. The immutable jobId selects the Job Store even when prNumber is zero; scheduled slot claims are atomic across processes. GitHub is **audit-only**: its PR/head/publish events are persisted for reporting, never consulted to start, stop, or complete local Workflows. Local Git delivery and its confirmed merge receipt—not a remote PR MERGED fact—gate Graph completion. Job creation and local Task operations require no GitHub authentication or PR.
 
-V2 separates **operational execution state** from that collaboration record. A local RelayStore may use SQLite/WAL for runtime snapshots, event idempotency and a durable GitHub projection outbox. ProjectedDurableStore bootstraps from the existing GitHub representation, commits Job/Plan/Task runtime changes locally, and lets GitHubProjectionWriter project them asynchronously. GitHub therefore remains the human-readable durable Job/Plan/Task/Review surface without being required for every high-frequency runtime transition.
 
 The canonical V2 architecture contract is
 [DESIGN-PRINCIPLES.md](DESIGN-PRINCIPLES.md). README sections below describe
@@ -10,23 +11,27 @@ the runtime; they do not replace that contract.
 
 ## V2 architecture
 
-```mermaid
+\`\`\`mermaid
 flowchart LR
-    Human[Human / orchestrator] --> GH[GitHub PR + comments<br/>collaboration + audit surface]
-    GH --> Inbound[Typed inbound GitHub facts]
-    Worker[Workers / adapters] --> Events[Event Bus<br/>lifecycle + progress facts]
-    Inbound --> Coord[ReconcileCoordinator]
-    Events --> Coord
-    Coord --> Graphs[Executable Mermaid graphs<br/>workflow authority]
-    Graphs --> Runtime[TypeScript primitives<br/>facts + guards + effects]
-    Runtime --> Store[(SQLite/WAL RelayStore<br/>operational execution truth)]
-    Store --> Outbox[Projection outbox]
-    Outbox --> Writer[GitHubProjectionWriter]
-    Writer --> GH
-    Store --> Views[Dashboard / scheduler / recovery]
-```
-
-RelayStore owns local operational execution facts; GitHub remains the human-readable collaboration and audit projection. Worker events are authoritative lifecycle inputs for model-backed tasks, but they are not a separate durable database. The graph engine owns workflow branching; TypeScript owns facts, persistence, locking/claims, I/O, and primitive guard/action implementations.
+    Human[Human / orchestrator] --> CLI[CLI / Dashboard]
+    CLI --> Store[(SQLite / WAL<br/>Job Task Plan Review truth)]
+    Worker[Workers / adapters] --> Events[EventBus<br/>wake + observations]
+    Events --> Coordinator[ReconcileCoordinator]
+    Store --> Coordinator
+    Coordinator --> Graphs[Canonical Mermaid Graph Engine]
+    Graphs --> Effects[Stateless actions / effects]
+    Effects --> Store
+    Store --> Views[Dashboard / Scheduler / Recovery]
+    Effects --> Outbox[Durable external-action outbox]
+    Outbox --> GH[GitHub Commit / PR / Review / Merge API]
+    GH --> Facts[Confirmed external facts]
+    Facts --> Store
+\`\`\`
+
+SQLite holds the sole lifecycle authority; the Graph Engine selects every transition.
+GitHub operations are explicitly requested and confirmed by adapters, never used to
+discover or reconstruct Job/Task state. EventBus delivery wakes reconciliation;
+it cannot replace the durable SQLite record.
 
 ### Workflow graph navigation
 
@@ -53,7 +58,7 @@ These paths always represent the current canonical graphs. Historical graph defi
 
 ## Quick start
 
-For GitHub-backed work, create or adopt the PR through Agents Relay itself. This guarantees the durable job marker exists before any managed task is submitted.
+For new work, create a local Job through Agents Relay. The CLI can bind a known PR number without GitHub access; creating a new PR head uses the external GitHub adapter. Tasks are validated against the SQLite Job, not GitHub markers.
 
 ~~~sh
 cat > job.md <<'EOF'

package/dist/adapters.js

@@ -146,7 +146,7 @@ export function parseDriverJson(output) {
     throw new Error('browser-worker driver returned no submitted receipt');
 }
 function browserWorkspaceCli(override = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
-    return override ? { command: override, prefix: [] } : { command: 'npx', prefix: ['browser-workspace'] };
+    return override ? { command: override, prefix: [] } : { command: 'uvx', prefix: ['browser-workspace'] };
 }
 function browserWorkspaceCommand(cli, args, stdin, signal) {
     return new Promise((resolve, reject) => {

package/dist/cli-blocker.js

@@ -1,5 +1,4 @@
-import { GitHubStore } from './store.js';
-import { githubAuthContext } from './github-auth.js';
+import { openLocalManagedStore } from './local-managed-store.js';
 import { registerBlockerDependency } from './blockers.js';
 import { arg, publishDependentUnblocked, repository, withEventBus } from './cli-support.js';
 import { usage } from './cli-help.js';
@@ -11,8 +10,7 @@ export async function runBlockerCommand(action, args) {
     const pr = Number(arg(args, '--pr'));
     if (!id || !Number.isInteger(pr) || pr <= 0)
         throw new Error('blocker commands require --repo, --pr, and --id for the blocker Job');
-    const auth = await githubAuthContext(args);
-    const blockerStore = new GitHubStore(auth.client, repo, pr, auth.trustedAuthors);
+    const blockerStore = openLocalManagedStore(repo, pr).store;
     if (action === 'show') {
         console.log(JSON.stringify(await blockerStore.load(id), null, 2));
         return;
@@ -36,7 +34,7 @@ export async function runBlockerCommand(action, args) {
     const relation = await registerBlockerDependency({
         blockerStore,
         blockerJobId: id,
-        dependentStore: new GitHubStore(auth.client, dependentRepo, dependentPr, auth.trustedAuthors),
+        dependentStore: openLocalManagedStore(dependentRepo, dependentPr).store,
         dependentJobId: dependentJob,
         dependentTaskId: dependentTask,
         resolutionMode: modeValue,

package/dist/cli-help.js

@@ -1,12 +1,14 @@
 export const usage = 'agents-relay <job|task|review|plan|blocker|projection|escalation|context|init|record|agent-register|agent-discover|status|reconcile|serve> [options]';
 const help = {
-    root: `Agents Relay coordinates durable asynchronous agent jobs through GitHub pull requests.
+    root: `Agents Relay coordinates durable asynchronous agent jobs through local SQLite and workflow graphs.
 
 Usage:
-  npx agents-relay <command> [options]
+  npx agents-relay <command> [options] [--no-github]
+
+--no-github: SQLite/Graph-only mode. GitHub auth/API, PR creation, merge and fetch are disabled. Local completion is Graph-owned.
 
 Commands:
-  job create|update|show|list|merge|unblock|cancel  Manage durable GitHub-backed jobs
+  job create|update|show|list|merge|unblock|cancel  Manage SQLite-authoritative jobs with optional GitHub PRs
   task create|update|show|list|complete|retry|unblock|cancel  Manage durable tasks
   review request           Request graph-owned review (optional thread override)
   plan                     Invoke the Planner for an existing managed Job
@@ -24,7 +26,7 @@ Commands:
 
 Run 'npx agents-relay <command> --help' for command options and examples.
 Use 'node dist/cli.js' only for explicit local development/demo mode.`,
-    job: `Manage GitHub-backed durable jobs.
+    job: `Manage SQLite-authoritative durable jobs.
 
 Usage:
   npx agents-relay job <create|update|show|list|merge|unblock|cancel> [options]
@@ -34,7 +36,7 @@ Actions:
   update  Partially update mutable metadata on a healthy existing Job
   show    Show one durable Job
   list    List managed Jobs in a repository
-  merge   Merge the backing PR and complete the Job
+  merge   Queue a retryable external PR merge; Graph completes the Job only after confirmation
   unblock Authoritatively invalidate current BLOCKED decisions and trigger replanning/resume
   cancel  Close the backing PR and cancel the Job
 
@@ -54,10 +56,10 @@ When provided, --thread-id persists a reviewer destination; otherwise the Job re
 
 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 durable Job and its trusted marker.
+    'job create': `Create a SQLite-authoritative Job.
 
 Required: --repo OWNER/REPO, --id JOB_ID, and either --head BRANCH or --pr NUMBER.
-With --head, reuse/create the PR for that head. With --pr, bind an existing unmanaged PR.
+With --head, reuse/create the PR for that head. With --pr, bind an external PR reference locally without a GitHub query.
 Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --no-review, --tag JSON, --reviewer-thread-id ID, --creator-thread-id ID. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
 Job creation always enables auto-merge and never creates executable tasks. The orchestrator decides the initial task batch separately. Re-running create against an already healthy Job is idempotent and does not mutate its metadata.
 
@@ -66,8 +68,8 @@ Example:
     'job update': `Partially update mutable metadata on a healthy existing Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
-Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, --project-path RELATIVE_PATH, --priority, --mode fixed|autonomous, --schedule, --tag JSON, --auto-merge|--no-auto-merge, --review|--no-review, --reviewer-thread-id ID, --creator-thread-id ID, and continuation options. Updating the objective also updates the PR body.
-Unspecified fields are preserved. Marker/binding corruption is never repaired implicitly; update fails with a precise diagnostic instead.
+Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, --project-path RELATIVE_PATH, --priority, --mode fixed|autonomous, --schedule, --tag JSON, --auto-merge|--no-auto-merge, --review|--no-review, --reviewer-thread-id ID, --creator-thread-id ID, and continuation options. The objective updates local SQLite; PR body changes are independent external actions.
+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`,
@@ -83,7 +85,7 @@ Required: --repo OWNER/REPO.
 
 Example:
   npx agents-relay job list --repo OWNER/REPO`,
-    'job merge': `Merge the backing pull request and complete the durable Job.
+    'job merge': `Request an idempotent external pull-request merge; return QUEUED until confirmed, when the Graph Engine completes the Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. The current PR head SHA is pinned into the merge request.`,
     'job unblock': `Authoritatively unblock the effective BLOCKED work Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Autonomous Jobs transition blocked work to historical UNBLOCKED state and wake Planner with unblock facts as Plan trigger/context; fixed Jobs record UNBLOCKED first and then resume according to fixed-job retry semantics.`,

package/dist/cli-job-create.js

@@ -0,0 +1,69 @@
+import { openLocalManagedStore } from './local-managed-store.js';
+import { createJobEntity } from './workflow/entity-creation.js';
+import { normalizeThreadId } from './reviewer-thread.js';
+import { discoverLocalRelayStoreSnapshots } from './relay-store.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Job lifecycle bootstrap: SQLite is authoritative. PR creation is an
+ * optional one-time external adapter; an explicit PR number is offline-safe.
+ */
+export async function ensureManagedGitHubJob(_client, repositoryName, _trustedAuthors, options) {
+    if (!options.id)
+        throw new Error('--id is required for managed local Jobs');
+    const number = options.prNumber ?? 0;
+    if (!Number.isInteger(number) || number < 0)
+        throw new Error('Invalid external PR binding number');
+    const pr = { number, title: options.title ?? options.id,
+        body: options.body ?? options.objective ?? '', state: 'OPEN', head: '', base: options.base ?? '' };
+    const directory = options.storeDirectory ?? join(homedir(), '.agents-relay', 'stores');
+    const alreadyKnown = (await discoverLocalRelayStoreSnapshots(directory)).flatMap(snapshot => snapshot.jobs.filter(job => job.id === options.id).map(job => ({ job, path: snapshot.path })));
+    if (alreadyKnown.length > 1)
+        throw new Error('Duplicate immutable Job ID across SQLite stores: ' + options.id);
+    if (alreadyKnown.length === 1) {
+        const existing = alreadyKnown[0].job;
+        if (existing.repository !== repositoryName || (options.prNumber !== undefined && existing.prNumber !== number))
+            throw new Error('Immutable Job ID is already bound to a different repository or external PR');
+        return { job: existing, pr: { ...pr, number: existing.prNumber } };
+    }
+    const local = openLocalManagedStore(repositoryName, number, {
+        directory, jobId: options.id, noGitHub: true,
+    });
+    try {
+        const existing = await local.relay.loadJob(options.id);
+        if (existing)
+            return { job: existing, pr };
+        const now = new Date().toISOString();
+        const job = createJobEntity({
+            id: options.id,
+            title: options.title || pr.title || 'Agents Relay job',
+            objective: options.objective || pr.body || undefined,
+            projectPath: options.projectPath,
+            description: pr.body || undefined,
+            priority: options.priority ?? 'P2',
+            executionMode: options.executionMode ?? 'fixed',
+            tag: options.tag,
+            autoMerge: true,
+            ...(options.localMergeSource && options.localMergeTarget ? { localMerge: { sourceRef: options.localMergeSource, targetRef: options.localMergeTarget, status: 'pending' } } : {}),
+            reviewEnabled: options.reviewEnabled ?? true,
+            ...(options.reviewerThreadId
+                ? { reviewerThreadId: normalizeThreadId(options.reviewerThreadId, 'reviewer thread ID') }
+                : {}),
+            ...(options.creatorThreadId
+                ? { creatorThreadId: normalizeThreadId(options.creatorThreadId, 'creator thread ID') }
+                : {}),
+            prNumber: pr.number,
+            repository: repositoryName,
+            continuation: options.continuation ?? null,
+            createdAt: now,
+            updatedAt: now,
+            tasks: [],
+            ...(options.schedule ? { schedule: options.schedule } : {}),
+        }, { activate: Boolean(options.schedule) });
+        await local.store.saveJob(job);
+        return { job: await local.store.load(options.id), pr };
+    }
+    finally {
+        local.relay.close();
+    }
+}

package/dist/cli-local-merge-config.js

@@ -0,0 +1,9 @@
+export function configureLocalGitMerge(job, source, target, localOnly) {
+    // The GitHub integration is observational; local merge applies in either mode.
+    void localOnly;
+    if (!source || !target)
+        throw new Error('Supply both --local-merge-source and --local-merge-target');
+    if (!['ACTIVE', 'DRAFT'].includes(job.state))
+        throw new Error('Cannot reconfigure merge of a terminal Job');
+    job.localMerge = { sourceRef: source, targetRef: target, status: 'pending' };
+}

package/dist/cli-support.js

@@ -1,6 +1,11 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { InMemoryStore, GitHubStore } from './store.js';
 import { githubAuthContext } from './github-auth.js';
+import { noGitHubMode } from './no-github.js';
+import { basename } from 'node:path';
+import { createJobIdRegistryResolver } from './local-job-registry.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { NatsEventBus, eventFor } from './events.js';
 import { parseJobSchedule } from './scheduler.js';
 import { parseJobTagJson } from './task-tag.js';
@@ -51,20 +56,32 @@ export async function textOption(args, inlineFlag, fileFlag) {
 export function integerArg(args, name, fallback) { if (!hasArg(args, name))
     return fallback; const value = Number(arg(args, name)); if (!Number.isInteger(value) || value < 0)
     throw new Error(`${name} must be a non-negative integer`); return value; }
-export function repository(args) { const value = arg(args, '--repo'); if (!value)
+export function repository(args) { const value = arg(args, '--repo'); if (!value && noGitHubMode(args))
+    return 'local/' + basename(process.cwd()); if (!value)
     throw new Error('--repo is required for GitHub-backed operation'); return value; }
 export function pullRequest(args) { const value = Number(arg(args, '--pr')); if (!Number.isInteger(value) || value <= 0)
     throw new Error('--pr is required for GitHub-backed operation'); return value; }
 async function localStore(file) { const parsed = JSON.parse(await readFile(file, 'utf8')); const store = new InMemoryStore(parsed); return { store, job: await store.load(parsed.id) }; }
 export async function githubStore(args) { const auth = await githubAuthContext(args); return new GitHubStore(auth.client, repository(args), pullRequest(args), auth.trustedAuthors); }
-export async function storeFor(args) { const repo = arg(args, '--repo'); const pr = arg(args, '--pr'); if (repo && pr) {
-    const store = await githubStore(args);
+export async function storeFor(args) {
+    const file = arg(args, '--file');
+    if (file) {
+        const loaded = await localStore(file);
+        return { ...loaded, localFile: file };
+    }
+    const repo = noGitHubMode(args) ? repository(args) : arg(args, '--repo');
     const jobId = arg(args, '--id');
-    if (!jobId)
-        throw new Error('--id is required for GitHub-backed operation');
-    return { store, job: await store.load(jobId), localFile: null };
-} const file = arg(args, '--file'); if (!file)
-    throw new Error('Local mode is demo/test only; pass --file explicitly'); const loaded = await localStore(file); return { store: loaded.store, job: loaded.job, localFile: file }; }
+    if (!repo || !jobId)
+        throw new Error('Local Job requires --repo and --id (or explicit --file)');
+    const directory = arg(args, '--store-dir') || join(homedir(), '.agents-relay', 'stores');
+    const binding = await createJobIdRegistryResolver(directory, new Map())(jobId);
+    if (!binding || binding.job.repository !== repo)
+        throw new Error('Immutable local Job not found for repository: ' + jobId);
+    const suppliedPr = arg(args, '--pr');
+    if (suppliedPr && binding.job.prNumber !== Number(suppliedPr))
+        throw new Error('Local Job external PR binding mismatch');
+    return { store: binding.store, job: await binding.store.load(jobId), localFile: null };
+}
 export async function saveLocal(file, job) { if (file)
     await writeFile(file, JSON.stringify(job, null, 2)); }
 export async function relayControlJob(args, jobId) {

package/dist/cli.js

@@ -1,26 +1,31 @@
 #!/usr/bin/env node
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { openLocalManagedStore } from './local-managed-store.js';
+import { configureLocalGitMerge } from './cli-local-merge-config.js';
+import { DisabledGitHubClient, noGitHubMode } from './no-github.js';
+import { discoverLocalRelayStoreSnapshots } from './relay-store.js';
 import { realpathSync } from 'node:fs';
 import { once } from 'node:events';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
-import { dashboardManagedJobs, InMemoryStore, GitHubStore, resolvePullRequest, listManagedGitHubJobs } from './store.js';
-import { githubAuthContext } from './github-auth.js';
+import { dashboardManagedJobs, InMemoryStore } from './store.js';
 import { taskOverallTimeoutMs } from './types.js';
 import { Reconciler } from './reconciler.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 export { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { CodexAdapter, ChatGptAdapter } from './adapters.js';
 import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
-import { eventFor } from './events.js';
 import { serveDashboard } from './dashboard.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { decisionMode, executionDecisionEngine } from './decision.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
-import { transitionJobEvent } from './scheduler.js';
 import { applyOrchestratorStartAction, applyOrchestratorCompleteAction, applyTaskHoldAction, applyTaskQueueAction, dispatchTaskAction } from './task-actions.js';
 import { applyJobActivateAction, applyJobCancelAction } from './job-actions.js';
 import { resolveExecutionContext } from './execution-context.js';
+import { startServiceExternalActionFlusher } from './service-external-actions.js';
+import { handleServicePublication } from './service-publication.js';
 import { defaultWorkspaceRoot, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
 import { runBlockerCommand } from './cli-blocker.js';
 import { runEscalationCommand } from './cli-escalation.js';
@@ -35,46 +40,10 @@ export { helpText } from './cli-help.js';
 import { runReviewCommand } from './cli-review.js';
 import { normalizeThreadId, runtimeReviewer } from './reviewer-thread.js';
 export { runtimeReviewer } from './reviewer-thread.js';
-import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, withEventBus } from './cli-support.js';
+import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, pullRequest, storeFor, saveLocal, eventBus, publishWake, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, withEventBus } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
-export async function ensureManagedGitHubJob(client, repositoryName, trustedAuthors, options) {
-    if (!options.id)
-        throw new Error('--id is required for managed GitHub jobs');
-    const pr = await resolvePullRequest(client, repositoryName, { prNumber: options.prNumber, head: options.head, base: options.base, title: options.title, body: options.body });
-    const store = new GitHubStore(client, repositoryName, pr.number, trustedAuthors);
-    try {
-        const existing = await store.load(options.id);
-        return { job: existing, pr };
-    }
-    catch (error) {
-        if (!(error instanceof Error) || !error.message.startsWith('JOB_MARKER_MISSING:'))
-            throw error;
-    }
-    const now = new Date().toISOString();
-    const job = createJobEntity({
-        id: options.id,
-        title: options.title || pr.title || 'Agents Relay job',
-        objective: options.objective || pr.body || undefined,
-        projectPath: options.projectPath,
-        description: pr.body || undefined,
-        priority: options.priority ?? 'P2',
-        executionMode: options.executionMode ?? 'fixed',
-        tag: options.tag,
-        autoMerge: true,
-        reviewEnabled: options.reviewEnabled ?? true,
-        ...(options.reviewerThreadId ? { reviewerThreadId: normalizeThreadId(options.reviewerThreadId, 'reviewer thread ID') } : {}),
-        ...(options.creatorThreadId ? { creatorThreadId: normalizeThreadId(options.creatorThreadId, 'creator thread ID') } : {}),
-        prNumber: pr.number,
-        repository: repositoryName,
-        continuation: options.continuation ?? null,
-        createdAt: now,
-        updatedAt: now,
-        tasks: [],
-        ...(options.schedule ? { schedule: options.schedule } : {}),
-    }, { activate: Boolean(options.schedule) });
-    await store.saveJob(job);
-    return { job: await store.load(options.id), pr };
-}
+import { ensureManagedGitHubJob } from './cli-job-create.js';
+export { ensureManagedGitHubJob } from './cli-job-create.js';
 async function workerTaskFromArgs(job, args, now) {
     const model = arg(args, '--model');
     const adapterValue = arg(args, '--adapter');
@@ -166,7 +135,7 @@ async function runManagedTaskCommand(action, args) {
 async function runTaskCommand(action, args) {
     if (!['create', 'update', 'show', 'list', 'start', 'complete', 'retry', 'unblock', 'cancel'].includes(action))
         throw new Error(usage);
-    const managed = Boolean(arg(args, '--repo') && arg(args, '--pr') && !arg(args, '--file'));
+    const managed = !noGitHubMode(args) && Boolean(arg(args, '--repo') && arg(args, '--pr') && !arg(args, '--file'));
     if (managed && ['create', 'start', 'complete', 'retry', 'cancel'].includes(action)) {
         await runManagedTaskCommand(action, args);
         return;
@@ -365,27 +334,35 @@ async function runJobCommand(action, args) {
         if (invalid)
             throw new Error(`job create does not accept task execution option ${invalid}; create the job first, then let the orchestrator create the initial plan/task batch`);
         createObjective = await textOption(args, '--objective', '--objective-file');
-        if (!arg(args, '--pr') && !createObjective.trim())
+        if ((!arg(args, '--pr') || noGitHubMode(args)) && !createObjective.trim())
             throw new Error('job create with --head requires --objective-file PATH|- or --objective MARKDOWN containing the complete standalone Job context');
     }
-    const auth = await githubAuthContext(args);
     if (action === 'list') {
-        console.log(JSON.stringify(await listManagedGitHubJobs(auth.client, repo, auth.trustedAuthors), null, 2));
+        const snapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+        const overviews = snapshots.flatMap(snapshot => snapshot.jobs.filter(job => job.repository === repo)
+            .map(job => ({
+            job, githubState: snapshot.facts?.state ?? 'UNKNOWN',
+            draft: false, mergedAt: null, closedAt: null, publication: snapshot.publications[job.id]?.latest ?? null, publicationFailure: snapshot.publications[job.id]?.failure ?? null,
+        })));
+        console.log(JSON.stringify(dashboardManagedJobs(overviews), null, 2));
         return;
     }
     const id = arg(args, '--id');
     if (!id)
-        throw new Error('--id is required for managed GitHub jobs');
+        throw new Error('--id is required for managed local Jobs');
     const prValue = arg(args, '--pr');
-    const prNumber = prValue ? Number(prValue) : undefined;
+    const prNumber = prValue ? Number(prValue) : 0;
     if (prValue && (!Number.isInteger(prNumber) || (prNumber ?? 0) <= 0))
         throw new Error('--pr must be a positive integer');
     if (action === 'create') {
-        if (!prNumber && !arg(args, '--head'))
-            throw new Error('job create requires either --head or --pr');
         const objective = createObjective ?? '';
+        if (hasArg(args, '--local-merge-source') !== hasArg(args, '--local-merge-target'))
+            throw new Error('Supply both --local-merge-source and --local-merge-target');
+        const auth = { client: new DisabledGitHubClient(), trustedAuthors: new Set() };
         const result = await ensureManagedGitHubJob(auth.client, repo, auth.trustedAuthors, {
-            id,
+            id, noGitHub: noGitHubMode(args),
+            localMergeSource: arg(args, '--local-merge-source') || undefined,
+            localMergeTarget: arg(args, '--local-merge-target') || undefined,
             title: arg(args, '--title') || undefined,
             objective: objective || undefined,
             projectPath: arg(args, '--project-path') || undefined,
@@ -405,10 +382,8 @@ async function runJobCommand(action, args) {
         console.log(JSON.stringify({ repository: repo, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state }, null, 2));
         return;
     }
-    if (!prNumber)
-        throw new Error(`job ${action} requires --pr`);
-    const store = new GitHubStore(auth.client, repo, prNumber, auth.trustedAuthors);
-    const job = await store.load(id);
+    const loaded = await storeFor(args);
+    const { store, job } = loaded;
     if (action === 'unblock') {
         await runJobUnblockCommand(args, store, job);
         return;
@@ -417,22 +392,14 @@ async function runJobCommand(action, args) {
         console.log(JSON.stringify(job, null, 2));
         return;
     }
-    await store.validateJobBinding(id);
+    if (job.repository !== repo || (prValue && job.prNumber !== prNumber)) {
+        throw new Error('Local Job/PR binding mismatch');
+    }
     if (action === 'merge') {
-        if (job.state === 'CANCELLED')
-            throw new Error(`Cannot merge cancelled job ${job.id}`);
-        const headSha = await store.headSha();
-        await store.mergePullRequest(headSha ?? undefined);
-        await transitionJobEvent(job, 'pr.merged');
-        await store.saveJob(job);
-        const resolved = await store.resolveBlockerDependents(id, 'merge');
-        await withEventBus(args, bus => publishDependentUnblocked(bus, resolved.unblocked, `Blocker Job ${id} resolved (merge)`));
-        console.log(JSON.stringify(await store.load(id), null, 2));
-        return;
+        throw new Error('GitHub is audit-only. Configure local merge source/target and reconcile the local Job instead.');
     }
     if (action === 'cancel') {
         await applyJobCancelAction(store, job);
-        await store.closePullRequest();
         console.log(JSON.stringify(await store.load(id), null, 2));
         return;
     }
@@ -446,6 +413,8 @@ async function runJobCommand(action, args) {
     }
     if (hasArg(args, '--project-path'))
         job.projectPath = arg(args, '--project-path') || undefined;
+    if (hasArg(args, '--local-merge-source') || hasArg(args, '--local-merge-target'))
+        configureLocalGitMerge(job, arg(args, '--local-merge-source'), arg(args, '--local-merge-target'), noGitHubMode(args));
     if (hasArg(args, '--priority'))
         job.priority = priority(args, job.priority ?? 'P2');
     if (hasArg(args, '--mode') || hasArg(args, '--execution-mode'))
@@ -481,7 +450,7 @@ async function runJobCommand(action, args) {
     console.log(JSON.stringify(await store.load(id), null, 2));
 }
 export function runtimePlanner(args) { const plannerCommand = arg([...args], '--planner-command'); const modelRuntime = arg([...args], '--codex', 'codex'); return plannerCommand ? new CommandObjectivePlanner(plannerCommand) : new AgentObjectivePlanner(modelRuntime); }
-export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(args), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: async (job) => resolveRepositoryProjectPath(await resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()), job.projectPath) }); }
+export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { noGitHub: noGitHubMode(args), owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(args), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: async (job) => resolveRepositoryProjectPath(await resolveManagedProjectPath(noGitHubMode(args) ? undefined : job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()), job.projectPath) }); }
 export function dashboardJobAction(store, reconciler, action) {
     return async (jobId) => {
         const job = await store.load(jobId);
@@ -491,7 +460,6 @@ export function dashboardJobAction(store, reconciler, action) {
         }
         else if (action === 'cancel') {
             await applyJobCancelAction(store, job);
-            await store.closePullRequest?.();
             return await store.load(job.id);
         }
         return await reconciler.wake(job.id);
@@ -505,17 +473,33 @@ export async function createService(args) {
     const usageWindowDays = Number.isInteger(requestedUsageDays) && requestedUsageDays > 0 ? requestedUsageDays : 1;
     const usageRegistry = codexAndZaiUsageRegistry(undefined, usageWindowDays);
     const reconciler = runtime(loaded.store, args, bus, usageRegistry);
-    const repo = arg(args, '--repo');
+    const repo = noGitHubMode(args) ? repository(args) : arg(args, '--repo');
     let overviewProvider;
     if (repo) {
-        const overviewAuth = await githubAuthContext(args);
-        overviewProvider = async () => dashboardManagedJobs(await listManagedGitHubJobs(overviewAuth.client, repo, overviewAuth.trustedAuthors));
+        overviewProvider = async () => {
+            const snapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+            return dashboardManagedJobs(snapshots.flatMap(snapshot => snapshot.jobs
+                .filter(job => job.repository === repo)
+                .map(job => ({
+                job, githubState: snapshot.facts?.state ?? 'UNKNOWN', draft: false,
+                mergedAt: null, closedAt: null, publication: snapshot.publications[job.id]?.latest ?? null, publicationFailure: snapshot.publications[job.id]?.failure ?? null,
+            }))));
+        };
     }
     const webhookSecret = arg(args, '--github-webhook-secret') || process.env.AGENTS_RELAY_GITHUB_WEBHOOK_SECRET || '';
-    const webhook = repo && webhookSecret ? { secret: webhookSecret, repositories: new Set([repo]), pullRequest: loaded.job.prNumber, wake: (event) => { const wakeEvent = eventFor(loaded.job.id, 'github', null, 'github.webhook', 'queued', 'GitHub webhook ' + event.event + (event.action ? ':' + event.action : ''), 'orchestrator', { deliveryId: event.deliveryId, event: event.event, action: event.action, repository: event.repository, prNumber: event.pullRequest }); if (bus)
-            void bus.publish(wakeEvent);
-        else
-            void reconciler.reconcile(loaded.job.id); } } : undefined;
+    const webhook = !noGitHubMode(args) && repo && webhookSecret ? {
+        secret: webhookSecret,
+        repositories: new Set([repo]),
+        pullRequest: loaded.job.prNumber,
+        wake: async (event) => {
+            if (event.pullRequestFacts && loaded.store.applyPullRequestFacts) {
+                await loaded.store.applyPullRequestFacts({
+                    ...event.pullRequestFacts, observedAt: event.pullRequestFacts.observedAt ?? new Date().toISOString(),
+                });
+            }
+            await handleServicePublication(await loaded.store.load(loaded.job.id), event, bus);
+        },
+    } : undefined;
     const dashboardServer = serveDashboard(loaded.store, Number(arg(args, '--port', String(SERVICE_DEFAULTS.port))), bus, Number(arg(args, '--refresh-ms', String(SERVICE_DEFAULTS.dashboardRefreshMs))), loaded.job.id, usageRegistry, overviewProvider, webhook, undefined, undefined, undefined, {
         start: dashboardJobAction(loaded.store, reconciler, 'start'),
         reconcile: dashboardJobAction(loaded.store, reconciler, 'reconcile'),
@@ -529,6 +513,7 @@ export async function createService(args) {
     const stopWatcher = await reconciler.watch(loaded.job.id);
     const watchdog = setInterval(() => void reconciler.reconcile(loaded.job.id), Number(arg(args, '--interval', String(SERVICE_DEFAULTS.watchdogMs))));
     watchdog.unref();
+    const stopExternalActions = startServiceExternalActionFlusher(loaded.store, reconciler, loaded.job.id, Number(arg(args, '--projection-ms', String(SERVICE_DEFAULTS.projectionFlushMs))));
     let stopping = null;
     const service = {
         store: loaded.store,
@@ -540,6 +525,7 @@ export async function createService(args) {
             if (stopping)
                 return stopping;
             clearInterval(watchdog);
+            stopExternalActions();
             service.watchdogCleared = true;
             const serverClosed = new Promise((resolve, reject) => { dashboardServer.close(error => error ? reject(error) : resolve()); });
             dashboardServer.closeAllConnections();
@@ -576,7 +562,7 @@ export function isEntrypoint(moduleUrl) {
     }
 }
 async function main() {
-    const [command, ...args] = process.argv.slice(2);
+    const [command, ...args] = process.argv.slice(2).filter(value => value !== '--no-github');
     if (!command || command === '--help' || command === '-h') {
         console.log(helpText());
         return;
@@ -626,7 +612,7 @@ async function main() {
         let store;
         let file = null;
         if (arg(args, '--repo') && arg(args, '--pr'))
-            store = await githubStore(args);
+            store = openLocalManagedStore(repository(args), pullRequest(args)).store;
         else {
             file = arg(args, '--file');
             if (!file)
@@ -709,7 +695,7 @@ async function main() {
     }
     if (command === 'reconcile') {
         await withEventBus(args, async (bus) => {
-            if (!localFile) {
+            if (!localFile && !noGitHubMode(args)) {
                 await requestManagedReconciliation(bus, job);
                 console.log(JSON.stringify(await store.load(job.id), null, 2));
                 return;

package/dist/dashboard-html.js

@@ -388,7 +388,7 @@ function jobChatRef(job){return repoName(job?.repository)+'/pr#'+value(job?.prNu
 function chatShortcutUrl(prompt){return 'https://chatgpt.com/?prompt='+encodeURIComponent(prompt);}
 const CHAT_SHORTCUT_TARGET='agents-relay-shortcut';
 function chatShortcutField(job){const box=element('div','detail-group');box.append(element('p','detail-label',text('ChatGPT shortcut')));const select=document.createElement('select');select.className='job-filter job-chat-shortcut-select';select.setAttribute('aria-label','ChatGPT shortcut');select.append(new Option('',''));for(const item of parseChatShortcuts(chatShortcutText()))select.append(new Option(item.name,item.prompt));select.value='';select.addEventListener('change',()=>{if(!select.value)return;const prompt=select.value.replaceAll('%1',jobChatRef(job));window.open(chatShortcutUrl(prompt),CHAT_SHORTCUT_TARGET,'noopener');select.value='';});box.append(select);return box;}
-function renderJobList(){jobList.replaceChildren();const visible=filteredJobs();if(!jobs.length){jobList.append(element('li','empty',text('No durable jobs discovered.')));return;}if(!visible.length){jobList.append(element('li','empty',text('No jobs match the selected repo.')));return;}for(const job of visible){const row=element('div','job-row'+(isCompleteUnmerged(job)?' complete-unmerged':''));row.setAttribute('aria-current',String(jobSelectionKey(job)===selectedJob));row.addEventListener('click',()=>selectJob(job));const content=element('div','job-content');const select=document.createElement('button');select.type='button';select.className='job-button';select.setAttribute('aria-current',String(jobSelectionKey(job)===selectedJob));select.title=job.title||job.id;select.addEventListener('click',event=>{event.stopPropagation();selectJob(job);});select.append(element('span','job-title',text(repoName(job.repository)+'/PR#'+value(job.prNumber)+': '+value(job.title||job.id))));const states=element('span','job-status-line');states.append(element('span','badge '+value(job.state),text(value(job.state))),element('span','badge '+value(job.runtimeStatus||'IDLE'),text(value(job.runtimeStatus||'IDLE'))));if(job.executionMode==='autonomous')states.append(element('span','badge flag-autonomous',text('AUTONOMOUS')));if(job.reviewEnabled!==false&&job.githubState!=='MERGED')states.append(element('span','badge flag-review',text('REVIEW REQUIRED')));if(job.githubState==='MERGED'&&job.publication?.version)states.append(element('span','badge SUCCEEDED',text('v'+job.publication.version)));if(isCompleteUnmerged(job))states.append(element('span','badge MERGE_PENDING',text('MERGE PENDING')));const primary=element('div','job-primary');primary.append(states);const lastLine=element('div','job-last-line');lastLine.append(element('span','subtle',text(compactCounts(counts(job.tasks)))),element('span','subtle',text(relativeTime(job.updatedAt))));content.append(select,primary,lastLine);row.append(content);jobList.append(element('li','',row));}}
+function renderJobList(){jobList.replaceChildren();const visible=filteredJobs();if(!jobs.length){jobList.append(element('li','empty',text('No durable jobs discovered.')));return;}if(!visible.length){jobList.append(element('li','empty',text('No jobs match the selected repo.')));return;}for(const job of visible){const row=element('div','job-row'+(isCompleteUnmerged(job)?' complete-unmerged':''));row.setAttribute('aria-current',String(jobSelectionKey(job)===selectedJob));row.addEventListener('click',()=>selectJob(job));const content=element('div','job-content');const select=document.createElement('button');select.type='button';select.className='job-button';select.setAttribute('aria-current',String(jobSelectionKey(job)===selectedJob));select.title=job.title||job.id;select.addEventListener('click',event=>{event.stopPropagation();selectJob(job);});select.append(element('span','job-title',text(repoName(job.repository)+'/PR#'+value(job.prNumber)+': '+value(job.title||job.id))));const states=element('span','job-status-line');states.append(element('span','badge '+value(job.state),text(value(job.state))),element('span','badge '+value(job.runtimeStatus||'IDLE'),text(value(job.runtimeStatus||'IDLE'))));if(job.executionMode==='autonomous')states.append(element('span','badge flag-autonomous',text('AUTONOMOUS')));if(job.reviewEnabled!==false&&job.githubState!=='MERGED')states.append(element('span','badge flag-review',text('REVIEW REQUIRED')));if(job.publication?.version)states.append(element('span','badge SUCCEEDED',text('v'+job.publication.version)));if(job.publicationFailure)states.append(element('span','badge FAILED',text('PUBLISH FAILED: '+value(job.publicationFailure.stage))));if(isCompleteUnmerged(job))states.append(element('span','badge MERGE_PENDING',text('MERGE PENDING')));const primary=element('div','job-primary');primary.append(states);const lastLine=element('div','job-last-line');lastLine.append(element('span','subtle',text(compactCounts(counts(job.tasks)))),element('span','subtle',text(relativeTime(job.updatedAt))));content.append(select,primary,lastLine);row.append(content);jobList.append(element('li','',row));}}
 function taskTagDisplay(job,task){const display=task.tag&&job?.tag?.values?.[task.tag];return typeof display==='string'&&display?display:null;}
 function taskSubtreeComplete(task,children){return ['SUCCEEDED','CANCELLED'].includes(task.state)&&(children.get(task.id)||[]).every(child=>taskSubtreeComplete(child,children));}
 function taskNode(task,children,depth){const li=element('li');const nested=children.get(task.id)||[];const line=element('div','task-line');if(nested.length){const key=(selectedJob||'')+':'+task.id;const collapsed=collapsedTasks.has(key)||(!expandedTasks.has(key)&&taskSubtreeComplete(task,children));const fold=document.createElement('button');fold.type='button';fold.className='task-fold';fold.setAttribute('aria-expanded',String(!collapsed));fold.setAttribute('aria-label',(collapsed?'Expand ':'Collapse ')+task.id);fold.textContent=collapsed?'▸':'▾';line.append(fold);const ul=element('ul','tree');ul.hidden=collapsed;for(const child of nested)ul.append(taskNode(child,children,depth+1));fold.addEventListener('click',()=>{const next=!ul.hidden;ul.hidden=next;fold.setAttribute('aria-expanded',String(!next));fold.setAttribute('aria-label',(next?'Expand ':'Collapse ')+task.id);fold.textContent=next?'▸':'▾';if(next){collapsedTasks.add(key);expandedTasks.delete(key);}else{collapsedTasks.delete(key);expandedTasks.add(key);}});li.append(line,ul);}else li.append(line);const row=document.createElement('button');row.type='button';row.className='task-row';row.setAttribute('aria-current',String(task.id===selectedTaskId));row.title=task.id;row.addEventListener('click',()=>{const deselect=selectedTaskId===task.id;selectedTaskId=deselect?null:task.id;eventTaskId=deselect?null:task.id;rememberSelection();clearEvents();renderAll();void loadEventHistory();});const id=element('span','task-id',text(task.id));id.style.paddingLeft=Math.min(depth,4)*6+'px';row.append(id,element('span','badge '+value(task.state),text(task.state)));const tag=taskTagDisplay(selected(),task);if(tag){const badge=element('span','task-tag',text(tag));badge.title=(selected()?.tag?.description||'Task tag')+': '+task.tag;row.append(badge);}line.append(row);return li;}