agents-relay 2.0.67 → 2.0.69

package/dist/cli.js

@@ -1,139 +1,48 @@
 #!/usr/bin/env node
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { configureLocalGitMerge } from './cli-local-merge-config.js';
+import { 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 { defaultWorkspaceRoot, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
+import { startServiceExternalActionFlusher } from './service-external-actions.js';
+import { handleServicePublication } from './service-publication.js';
+import { defaultWorkspaceRoot, prepareLocalJobExecutionWorktree, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
 import { runBlockerCommand } from './cli-blocker.js';
 import { runEscalationCommand } from './cli-escalation.js';
 import { runProjectionCommand } from './cli-projection.js';
 import { helpText, usage } from './cli-help.js';
 import { parseAgentGraph } from './agent-graph.js';
-import { runJobUnblockCommand, runTaskUnblockCommand } from './cli-unblock.js';
-import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js';
+import { runTaskUnblockCommand } from './cli-unblock.js';
+import { createJobEntity } from './workflow/entity-creation.js';
 import { runCliEntrypoint } from './cli-shutdown.js';
 import { shutdownOwnedProcesses } from './owned-process.js';
 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, storeFor, saveLocal, eventBus, publishWake, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayControlCommand, relayJobList, relayJobStateCommand, 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 };
-}
-async function workerTaskFromArgs(job, args, now) {
-    const model = arg(args, '--model');
-    const adapterValue = arg(args, '--adapter');
-    const adapter = (adapterValue || 'codex');
-    const outputKind = arg(args, '--output');
-    const outputPath = arg(args, '--output-path');
-    const input = await textOption(args, '--input', '--input-file');
-    const agentGraph = hasArg(args, '--agent-graph') || hasArg(args, '--agent-graph-file') ? await textOption(args, '--agent-graph', '--agent-graph-file') : undefined;
-    if (agentGraph)
-        parseAgentGraph(agentGraph);
-    if (!input.trim())
-        throw new Error('task create requires --input-file PATH|- or --input MARKDOWN');
-    if (!['codex', 'chatgpt', 'orchestrator'].includes(adapter))
-        throw new Error('task create --adapter must be codex, chatgpt, or orchestrator');
-    if (outputKind !== 'task-pr' && outputKind !== 'file')
-        throw new Error('task create requires --output task-pr|file');
-    if (outputKind === 'file' && !outputPath)
-        throw new Error('--output file requires --output-path');
-    if (adapter !== 'orchestrator' && ['--provider', '--profile', '--reasoning', '--cwd', '--chatgpt-project'].some(flag => hasArg(args, flag)) && !model)
-        throw new Error('task create explicit routing requires --model');
-    const routing = adapter === 'orchestrator' || !model ? undefined : { provider: arg(args, '--provider', 'openai'), model, profile: arg(args, '--profile') || undefined, reasoning: arg(args, '--reasoning') || undefined, cwd: arg(args, '--cwd') || undefined, projectId: arg(args, '--chatgpt-project') || undefined, decidedBy: 'cli', decidedAt: now };
-    const workerRequirements = adapter === 'orchestrator' || routing ? undefined : { capabilities: [], runtime: adapterValue ? adapter : undefined };
-    const closePolicy = hasArg(args, '--chatgpt-tab-close-policy') ? chatGptTabClosePolicy(args) : undefined;
-    const size = storySize(args);
-    const dependencies = arg(args, '--deps').split(',').filter(Boolean);
-    const timeoutMs = adapter === 'orchestrator' ? 0 : hasArg(args, '--timeout') ? integerArg(args, '--timeout', taskOverallTimeoutMs(size, routing?.reasoning)) : routing ? taskOverallTimeoutMs(size, routing.reasoning) : 0;
-    return createTaskEntity(job, {
-        jobId: job.id,
-        id: arg(args, '--task-id', 'initial'),
-        priority: priority(args, job.priority ?? 'P2'),
-        storySize: size,
-        projectName: arg(args, '--project') || undefined,
-        agentName: arg(args, '--agent') || undefined,
-        agentGraph,
-        parentTaskId: arg(args, '--parent') || null,
-        dependencies,
-        capabilities: arg(args, '--capabilities').split(',').filter(Boolean),
-        workerRequirements,
-        adapter,
-        chatgptTabClosePolicy: closePolicy,
-        input: input || 'true',
-        attachments: arg(args, '--attachments').split(',').filter(Boolean),
-        output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' },
-        routing,
-        continuation: continuation(args),
-        continuationDeliveredAt: null,
-        attempt: 0,
-        maxAttempts: Number(arg(args, '--max-attempts', '3')),
-        leaseOwner: null,
-        leaseExpiresAt: null,
-        executionId: null,
-        threadId: null,
-        result: null,
-        error: null,
-        timeoutMs,
-        createdAt: now,
-        updatedAt: now
-    }, { defer: hasArg(args, '--draft') });
-}
+import { workerTaskFromArgs } from './cli-worker-task.js';
+export { ensureManagedGitHubJob } from './cli-job-create.js';
 async function runManagedTaskCommand(action, args) {
     const jobId = arg(args, '--id');
     if (!jobId)
@@ -164,16 +73,100 @@ async function runManagedTaskCommand(action, args) {
     console.log(JSON.stringify(task, null, 2));
 }
 async function runTaskCommand(action, args) {
-    if (!['create', 'update', 'show', 'list', 'start', 'complete', 'retry', 'unblock', 'cancel'].includes(action))
+    if (!['create', 'update', 'show', 'list', 'start', 'complete', 'retry', 'recover', 'unblock', 'cancel'].includes(action))
         throw new Error(usage);
-    const managed = Boolean(arg(args, '--repo') && arg(args, '--pr') && !arg(args, '--file'));
-    if (managed && ['create', 'start', 'complete', 'retry', 'cancel'].includes(action)) {
-        await runManagedTaskCommand(action, args);
-        return;
+    const managed = !arg(args, '--file') && Boolean(arg(args, '--repo') && arg(args, '--id'));
+    if (managed) {
+        const jobId = arg(args, '--id');
+        if (action === 'list') {
+            const job = await relayControlJob(args, jobId);
+            console.log(JSON.stringify(job.tasks, null, 2));
+            return;
+        }
+        const taskId = arg(args, '--task-id', action === 'create' ? randomUUID() : '');
+        if (action === 'show') {
+            if (!taskId)
+                throw new Error('task show requires --task-id');
+            const job = await relayControlJob(args, jobId);
+            const task = job.tasks.find(item => item.id === taskId);
+            if (!task)
+                throw new Error(`Task ${taskId} not found`);
+            console.log(JSON.stringify(task, null, 2));
+            return;
+        }
+        if (['create', 'start', 'complete', 'retry', 'cancel'].includes(action)) {
+            await runManagedTaskCommand(action, args);
+            return;
+        }
+        if (action === 'recover') {
+            if (!taskId)
+                throw new Error('task recover requires --task-id');
+            const recoveryTaskId = arg(args, '--recovery-task-id');
+            if (!recoveryTaskId)
+                throw new Error('task recover requires --recovery-task-id');
+            const job = await relayControlCommand(args, { command: 'task.recover', jobId, taskId, recoveryTaskId });
+            console.log(JSON.stringify(job.tasks.find(item => item.id === taskId), null, 2));
+            return;
+        }
+        if (action === 'unblock') {
+            if (!taskId)
+                throw new Error('task unblock requires --task-id');
+            const reason = arg(args, '--reason');
+            if (!reason.trim())
+                throw new Error('task unblock requires --reason');
+            const job = await relayControlCommand(args, { command: 'task.unblock', jobId, taskId, reason });
+            console.log(JSON.stringify(job.tasks.find(item => item.id === taskId), null, 2));
+            return;
+        }
+        if (action === 'update') {
+            const job = await relayControlJob(args, jobId);
+            const task = job.tasks.find(item => item.id === taskId);
+            if (!task)
+                throw new Error(`Task ${taskId} not found`);
+            const expectedUpdatedAt = task.updatedAt;
+            if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
+                throw new Error(`Task ${taskId} is ${task.state}; durable execution fields are immutable in this state`);
+            if (hasArg(args, '--adapter')) {
+                const adapter = arg(args, '--adapter');
+                if (!['codex', 'chatgpt', 'orchestrator'].includes(adapter))
+                    throw new Error('--adapter must be codex, chatgpt, or orchestrator');
+                task.adapter = adapter;
+            }
+            if (hasArg(args, '--priority'))
+                task.priority = priority(args, task.priority ?? job.priority ?? 'P2');
+            if (hasArg(args, '--story-size')) {
+                task.storySize = storySize(args, task.storySize ?? 'M');
+                if (!hasArg(args, '--timeout'))
+                    task.timeoutMs = taskOverallTimeoutMs(task.storySize, task.routing?.reasoning);
+            }
+            if (hasArg(args, '--input') || hasArg(args, '--input-file'))
+                task.input = await textOption(args, '--input', '--input-file');
+            if (hasArg(args, '--project'))
+                task.projectName = arg(args, '--project') || undefined;
+            if (hasArg(args, '--agent'))
+                task.agentName = arg(args, '--agent') || undefined;
+            if (hasArg(args, '--parent'))
+                task.parentTaskId = arg(args, '--parent') || null;
+            if (hasArg(args, '--deps'))
+                task.dependencies = arg(args, '--deps').split(',').filter(Boolean);
+            if (hasArg(args, '--capabilities'))
+                task.capabilities = arg(args, '--capabilities').split(',').filter(Boolean);
+            task.timeoutMs = integerArg(args, '--timeout', task.timeoutMs);
+            task.maxAttempts = integerArg(args, '--max-attempts', task.maxAttempts);
+            if (hasArg(args, '--draft') && hasArg(args, '--queue'))
+                throw new Error('--draft and --queue are mutually exclusive');
+            if (hasArg(args, '--draft') && task.state === 'QUEUED')
+                await applyTaskHoldAction(task);
+            if (hasArg(args, '--queue'))
+                await applyTaskQueueAction(job, task);
+            const updated = await relayTaskCommand(args, { jobId, taskId, action: 'update', task, expectedUpdatedAt });
+            console.log(JSON.stringify(updated.tasks.find(item => item.id === taskId), null, 2));
+            return;
+        }
     }
     const loaded = await storeFor(args);
     const { store, localFile } = loaded;
-    const job = managed && action === 'update' ? await relayControlJob(args, loaded.job.id) : loaded.job;
+    const job = loaded.job;
     if (action === 'list') {
         console.log(JSON.stringify(job.tasks, null, 2));
         return;
@@ -227,11 +220,14 @@ async function runTaskCommand(action, args) {
         console.log(JSON.stringify(task, null, 2));
         return;
     }
-    if (action === 'retry' || action === 'cancel') {
+    if (action === 'retry' || action === 'recover' || action === 'cancel') {
         let outputJob = job;
         let outputTask = task;
-        if (action === 'retry') {
-            const result = await dispatchTaskAction(store, { id: 'task.retry', jobId: job.id, taskId: id });
+        if (action === 'retry' || action === 'recover') {
+            const recoveryTaskId = action === 'recover' ? arg(args, '--recovery-task-id') : '';
+            if (action === 'recover' && !recoveryTaskId)
+                throw new Error('task recover requires --recovery-task-id');
+            const result = await dispatchTaskAction(store, { id: action === 'recover' ? 'task.recover' : 'task.retry', jobId: job.id, taskId: id, ...(recoveryTaskId ? { recoveryTaskId } : {}) });
             if (result.job.state === 'DRAFT') {
                 await applyJobActivateAction(result.job);
                 await store.saveJob(result.job);
@@ -365,75 +361,57 @@ 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));
+        console.log(JSON.stringify(await relayJobList(args), 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 ?? '';
-        const result = await ensureManagedGitHubJob(auth.client, repo, auth.trustedAuthors, {
-            id,
-            title: arg(args, '--title') || undefined,
-            objective: objective || undefined,
-            projectPath: arg(args, '--project-path') || undefined,
-            priority: priority(args),
-            executionMode: requestedExecutionMode(args),
-            schedule: scheduleFromArgs(args),
-            tag: jobTagFromArgs(args),
-            reviewEnabled: !hasArg(args, '--no-review'),
-            continuation: continuation(args),
-            ...(hasArg(args, '--reviewer-thread-id') ? { reviewerThreadId: arg(args, '--reviewer-thread-id') } : {}),
-            ...(hasArg(args, '--creator-thread-id') ? { creatorThreadId: arg(args, '--creator-thread-id') } : {}),
-            prNumber,
-            head: arg(args, '--head') || undefined,
-            base: arg(args, '--base', 'main'),
-            body: arg(args, '--body') || objective || undefined
-        });
-        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);
+        if (hasArg(args, '--local-merge-source') !== hasArg(args, '--local-merge-target'))
+            throw new Error('Supply both --local-merge-source and --local-merge-target');
+        const result = await relayControlCommand(args, { command: 'job.create', repository: repo, initialPlan: hasArg(args, '--initial-plan'), options: {
+                id, title: arg(args, '--title') || undefined, objective: objective || undefined, projectPath: arg(args, '--project-path') || undefined,
+                priority: priority(args), executionMode: requestedExecutionMode(args), schedule: scheduleFromArgs(args), tag: jobTagFromArgs(args), reviewEnabled: !hasArg(args, '--no-review'), continuation: continuation(args),
+                reviewerThreadId: hasArg(args, '--reviewer-thread-id') ? arg(args, '--reviewer-thread-id') : undefined, creatorThreadId: hasArg(args, '--creator-thread-id') ? arg(args, '--creator-thread-id') : undefined,
+                prNumber, head: arg(args, '--head') || undefined, base: arg(args, '--base', 'main'), body: arg(args, '--body') || objective || undefined,
+                localMergeSource: arg(args, '--local-merge-source') || undefined, localMergeTarget: arg(args, '--local-merge-target') || undefined,
+            } });
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const job = await relayControlJob(args, id);
     if (action === 'unblock') {
-        await runJobUnblockCommand(args, store, job);
+        const reason = arg(args, '--reason');
+        if (!reason.trim())
+            throw new Error('job unblock requires --reason');
+        const updated = await relayControlCommand(args, { command: 'job.unblock', jobId: id, reason });
+        console.log(JSON.stringify(updated, null, 2));
         return;
     }
     if (action === 'show') {
         console.log(JSON.stringify(job, null, 2));
         return;
     }
-    await store.validateJobBinding(id);
+    const boundPrNumber = job.externalPrNumber ?? (job.prNumber > 0 ? job.prNumber : 0);
+    if (job.repository !== repo || (prValue && boundPrNumber !== 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));
+        const updated = await relayJobStateCommand(args, job.id, 'CANCELLED');
+        console.log(JSON.stringify(updated, null, 2));
         return;
     }
     if (hasArg(args, '--title'))
@@ -446,6 +424,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'))
@@ -476,12 +456,13 @@ async function runJobCommand(action, args) {
             throw new Error('--continue-kind and --continue-target must be supplied together');
         job.continuation = next;
     }
-    job.updatedAt = new Date().toISOString();
-    await store.saveJob(job);
-    console.log(JSON.stringify(await store.load(id), null, 2));
+    const patch = {};
+    for (const key of ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'continuation', 'localMerge'])
+        patch[key] = job[key];
+    console.log(JSON.stringify(await relayControlCommand(args, { command: 'job.update', jobId: id, patch }), 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) => { const workspaceRoot = arg(args, '--workspace-root') || defaultWorkspaceRoot(); const canonical = await resolveManagedProjectPath(noGitHubMode(args) ? undefined : job.repository, arg(args, '--project-path'), workspaceRoot); return job.prNumber === 0 && job.localMerge?.sourceRef ? prepareLocalJobExecutionWorktree(canonical, job, workspaceRoot) : resolveRepositoryProjectPath(canonical, job.projectPath); } }); }
 export function dashboardJobAction(store, reconciler, action) {
     return async (jobId) => {
         const job = await store.load(jobId);
@@ -491,7 +472,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 +485,34 @@ 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.externalPrNumber ?? loaded.job.prNumber,
+        jobId: loaded.job.id,
+        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 +526,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 +538,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 +575,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;
@@ -620,19 +619,18 @@ async function main() {
         return;
     }
     if (command === 'init') {
+        const file = arg(args, '--file');
         const now = new Date().toISOString();
         const initialSchedule = scheduleFromArgs(args);
-        const job = createJobEntity({ id: arg(args, '--id', randomUUID()), title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), schedule: initialSchedule, autoMerge: !hasArg(args, '--no-auto-merge'), reviewEnabled: !hasArg(args, '--no-review'), prNumber: Number(arg(args, '--pr', '0')), repository: arg(args, '--repo'), continuation: continuation(args), createdAt: now, updatedAt: now, tasks: [] }, { activate: Boolean(initialSchedule) });
-        let store;
-        let file = null;
-        if (arg(args, '--repo') && arg(args, '--pr'))
-            store = await githubStore(args);
-        else {
-            file = arg(args, '--file');
-            if (!file)
-                throw new Error('init requires --repo/--pr or explicit --file demo mode');
-            store = new InMemoryStore(job);
+        const id = arg(args, '--id', randomUUID());
+        if (!file) {
+            const repo = repository(args);
+            const result = await relayControlCommand(args, { command: 'job.create', repository: repo, options: { id, title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), schedule: initialSchedule, reviewEnabled: !hasArg(args, '--no-review'), continuation: continuation(args), prNumber: Number(arg(args, '--pr', '0')) || 0 } });
+            console.log(JSON.stringify(result, null, 2));
+            return;
         }
+        const job = createJobEntity({ id, title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), schedule: initialSchedule, autoMerge: !hasArg(args, '--no-auto-merge'), reviewEnabled: !hasArg(args, '--no-review'), prNumber: Number(arg(args, '--pr', '0')), repository: arg(args, '--repo'), continuation: continuation(args), createdAt: now, updatedAt: now, tasks: [] }, { activate: Boolean(initialSchedule) });
+        const store = new InMemoryStore(job);
         await store.saveJob(job);
         await saveLocal(file, job);
         console.log(`Initialized ${job.id}`);
@@ -655,6 +653,46 @@ async function main() {
         console.log(JSON.stringify(await response.json(), null, 2));
         return;
     }
+    if (!arg(args, '--file') && ['plan', 'reconcile', 'record', 'agent-register', 'agent-discover'].includes(command)) {
+        const jobId = arg(args, '--id');
+        if (!jobId)
+            throw new Error(`${command} requires --repo and --id`);
+        if (command === 'plan') {
+            const guidance = hasArg(args, '--prompt') || hasArg(args, '--prompt-file') ? await textOption(args, '--prompt', '--prompt-file') : undefined;
+            console.log(JSON.stringify(await relayControlCommand(args, { command: 'job.plan', jobId, ...(guidance?.trim() ? { guidance: guidance.trim() } : {}) }), null, 2));
+            return;
+        }
+        if (command === 'reconcile') {
+            console.log(JSON.stringify(await relayControlCommand(args, { command: 'job.reconcile', jobId }), null, 2));
+            return;
+        }
+        if (command === 'record') {
+            const now = new Date().toISOString();
+            const id = arg(args, '--task-id', randomUUID());
+            const summary = arg(args, '--summary');
+            if (!summary)
+                throw new Error('record requires --summary');
+            const commit = arg(args, '--commit');
+            const task = { jobId, id, projectName: arg(args, '--project') || undefined, agentName: arg(args, '--agent', 'orchestrator'), parentTaskId: arg(args, '--parent') || null, dependencies: arg(args, '--deps').split(',').filter(Boolean), capabilities: [], adapter: 'orchestrator', input: arg(args, '--input', summary), continuation: null, continuationDeliveredAt: null, state: 'SUCCEEDED', attempt: 1, maxAttempts: 1, leaseOwner: null, leaseExpiresAt: null, executionId: commit || null, threadId: null, result: { summary, data: commit ? { commit } : undefined }, error: null, timeoutMs: 0, createdAt: now, updatedAt: now };
+            const updated = await relayControlCommand(args, { command: 'record', jobId, task });
+            console.log(JSON.stringify(updated.tasks.find(item => item.id === id), null, 2));
+            return;
+        }
+        if (command === 'agent-register') {
+            const now = new Date().toISOString();
+            const agent = { id: arg(args, '--agent-id', randomUUID()), name: arg(args, '--name'), responsibility: arg(args, '--responsibility'), role: arg(args, '--role'), capabilities: arg(args, '--capabilities').split(',').filter(Boolean), boundaries: arg(args, '--boundaries').split('|').filter(Boolean), endpoint: { kind: arg(args, '--endpoint-kind', 'adapter'), target: arg(args, '--endpoint') }, runtime: { adapter: arg(args, '--runtime', arg(args, '--adapter', 'shell')), provider: arg(args, '--provider') || undefined, model: arg(args, '--model') || undefined }, availability: arg(args, '--availability', 'available'), routing: { labels: arg(args, '--labels').split(',').filter(Boolean).reduce((out, item) => { const [key, value] = item.split('=', 2); if (key && value)
+                        out[key] = value; return out; }, {}), trustDomains: arg(args, '--trust-domains').split(',').filter(Boolean), regions: arg(args, '--regions').split(',').filter(Boolean) }, evidence: { evaluations: [], outcomes: { succeeded: 0, failed: 0, timedOut: 0 }, lastObservedAt: null }, registeredAt: now, updatedAt: now };
+            if (!agent.name || !agent.responsibility || !agent.role || !agent.endpoint.target)
+                throw new Error('--name, --responsibility, --role, and --endpoint are required');
+            console.log(JSON.stringify(await relayControlCommand(args, { command: 'agent.register', jobId, agent }), null, 2));
+            return;
+        }
+        if (command === 'agent-discover') {
+            const requirements = { capabilities: arg(args, '--capabilities').split(',').filter(Boolean), runtime: arg(args, '--runtime') || undefined, availability: arg(args, '--availability').split(',').filter(Boolean), trustDomain: arg(args, '--trust-domain') || undefined, taskKind: arg(args, '--task-kind') || undefined, explore: args.includes('--explore') };
+            console.log(JSON.stringify(await relayControlCommand(args, { command: 'agent.discover', jobId, requirements }), null, 2));
+            return;
+        }
+    }
     const loaded = await storeFor(args);
     const { store, job, localFile } = loaded;
     if (command === 'plan') {
@@ -709,7 +747,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;