agents-relay 2.0.68 → 2.0.70

package/dist/cli-worker-task.js

@@ -0,0 +1,63 @@
+import { taskOverallTimeoutMs } from './types.js';
+import { arg, hasArg, textOption, integerArg, chatGptTabClosePolicy, storySize, priority, continuation } from './cli-support.js';
+import { parseAgentGraph } from './agent-graph.js';
+import { createTaskEntity } from './workflow/entity-creation.js';
+export 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') });
+}

package/dist/cli.js

@@ -1,10 +1,7 @@
 #!/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 { noGitHubMode } from './no-github.js';
+import { discoverLocalRelayStoreSnapshots, relayStoreDirectory } from './relay-store.js';
 import { realpathSync } from 'node:fs';
 import { once } from 'node:events';
 import { fileURLToPath } from 'node:url';
@@ -26,83 +23,24 @@ 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 { 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, pullRequest, storeFor, saveLocal, eventBus, publishWake, 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';
-import { ensureManagedGitHubJob } from './cli-job-create.js';
+import { workerTaskFromArgs } from './cli-worker-task.js';
 export { ensureManagedGitHubJob } from './cli-job-create.js';
-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') });
-}
 async function runManagedTaskCommand(action, args) {
     const jobId = arg(args, '--id');
     if (!jobId)
@@ -133,16 +71,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 = !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;
+    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;
@@ -196,11 +218,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);
@@ -338,13 +363,7 @@ async function runJobCommand(action, args) {
             throw new Error('job create with --head requires --objective-file PATH|- or --objective MARKDOWN containing the complete standalone Job context');
     }
     if (action === 'list') {
-        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));
+        console.log(JSON.stringify(await relayJobList(args), null, 2));
         return;
     }
     const id = arg(args, '--id');
@@ -358,49 +377,39 @@ async function runJobCommand(action, args) {
         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, 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,
-            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));
+        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 loaded = await storeFor(args);
-    const { store, job } = loaded;
+    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;
     }
-    if (job.repository !== repo || (prValue && job.prNumber !== prNumber)) {
+    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') {
         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);
-        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'))
@@ -445,12 +454,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, { 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 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);
@@ -477,7 +487,7 @@ export async function createService(args) {
     let overviewProvider;
     if (repo) {
         overviewProvider = async () => {
-            const snapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+            const snapshots = await discoverLocalRelayStoreSnapshots(relayStoreDirectory());
             return dashboardManagedJobs(snapshots.flatMap(snapshot => snapshot.jobs
                 .filter(job => job.repository === repo)
                 .map(job => ({
@@ -490,7 +500,8 @@ export async function createService(args) {
     const webhook = !noGitHubMode(args) && repo && webhookSecret ? {
         secret: webhookSecret,
         repositories: new Set([repo]),
-        pullRequest: loaded.job.prNumber,
+        pullRequest: loaded.job.externalPrNumber ?? loaded.job.prNumber,
+        jobId: loaded.job.id,
         wake: async (event) => {
             if (event.pullRequestFacts && loaded.store.applyPullRequestFacts) {
                 await loaded.store.applyPullRequestFacts({
@@ -606,19 +617,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 = openLocalManagedStore(repository(args), pullRequest(args)).store;
-        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}`);
@@ -641,6 +651,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') {