agents-relay 1.0.50 → 1.0.52

package/README.md

@@ -11,11 +11,11 @@ npx agents-relay job create --repo OWNER/REPO --head feat/example --base main \
   --id job-1 --title "Objective" --body "PR description" --mode fixed
 
 # The orchestrator decides the initial batch separately
-npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 \
+npx agents-relay task create --repo OWNER/REPO --pr 12 --id job-1 \
   --task-id initial --adapter codex --provider openai --model MODEL --output task-pr \
   --input "Implement the objective and publish a terminal event."
 
-npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 \
+npx agents-relay task create --repo OWNER/REPO --pr 12 --id job-1 \
   --task-id child --adapter codex --provider openai --model MODEL --output task-pr \
   --input "Implement the described child task and publish a terminal event."
 
@@ -33,9 +33,8 @@ npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id chil
 
 Jobs default to `fixed`. `job create` persists only the durable job and never
 creates executable tasks. The top-level orchestrator decides whether the user's
-request should start immediately and, if so, submits the first task batch
-separately. That submit path records the orchestrator planning decision used as
-the provenance root for those tasks. A zero-task autonomous job remains idle;
+request should start immediately and, if so, creates the first task batch
+separately. Direct orchestrator-created tasks are persisted directly and are not wrapped in a synthetic Plan. A zero-task autonomous job remains idle;
 reconciliation does not invent its first planner. After an autonomous job has
 been explicitly started, later planning rounds may extend the work. Fixed jobs
 never grow another planning round.
@@ -55,7 +54,7 @@ A repository heartbeat invokes `tick` at 10-minute resolution. See
 [Scheduled autonomous jobs](docs/scheduled-autonomous-jobs.md) for the exact
 operational contract.
 
-job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker. Job creation is always create-only. Task execution options belong to `submit`, and the orchestrator may submit zero, one, or multiple initial tasks according to user intent.
+job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker. Job creation is always create-only. Task execution options belong to `task create`, and the orchestrator may create zero, one, or multiple initial Tasks according to user intent.
 
 To create a Job on an existing unmanaged PR, use the same `job create` action with `--pr` instead of `--head`:
 
@@ -71,7 +70,7 @@ npx agents-relay job update --repo OWNER/REPO --pr 6 --id job-6 --priority P0 --
 
 `job update` validates the trusted Job marker first. Missing, malformed, duplicated, mismatched, or conflicting bindings fail with a precise diagnostic and are not repaired implicitly. The orchestrator handles exceptional repair explicitly according to the Job contract, then retries the update. `job show` reads one Job and `job list` lists managed Jobs in a repository.
 
-Managed GitHub submit/reconcile/retry/cancel/serve commands also require a durable Job marker. Orchestrators do not need raw GitHub commands for normal Job creation or metadata updates: Agents Relay uses its authenticated GitHub client internally.
+Managed GitHub task create/update/show/list/retry/cancel and reconcile/serve commands also require a durable Job marker. Orchestrators do not need raw GitHub commands for normal Job creation or metadata updates: Agents Relay uses its authenticated GitHub client internally.
 
 The original init command remains supported for backward compatibility:
 
@@ -91,7 +90,7 @@ For explicit local demo/test mode:
 npm install
 npm run build
 node dist/cli.js init --file .agents-relay.json --title "Dogfood" --id demo
-node dist/cli.js submit --file .agents-relay.json --task-id hello --adapter codex --provider openai --model MODEL --output task-pr --input "Complete the described task"
+node dist/cli.js task create --file .agents-relay.json --task-id hello --adapter codex --provider openai --model MODEL --output task-pr --input "Complete the described task"
 node dist/cli.js reconcile --file .agents-relay.json
 npx agents-relay serve --file .agents-relay.json
 ~~~
@@ -143,7 +142,7 @@ For Codex and ChatGPT, **events are authoritative task state**. Event publicatio
 The ChatGPT adapter uses the `chatgpt-browser-worker` path selected by the shared execution-context resolver; Relay does not bundle its own copy. The resolver applies project-local > Neo shared > global `~/.agents` precedence at execution time, so durable tasks store names/intent rather than stale absolute skill paths. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and does not poll for the assistant response, resume/reopen a thread, or use conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
 
 ~~~sh
-npx agents-relay submit --repo OWNER/REPO --pr 5 --id job-1 \
+npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \
   --task-id research-ui --adapter chatgpt \
   --capabilities model,chatgpt,browser-harness \
   --provider openai --model MODEL \
@@ -153,4 +152,4 @@ npx agents-relay submit --repo OWNER/REPO --pr 5 --id job-1 \
 
 GitHub PR state is authoritative for terminal lifecycle: a merged PR reconciles its managed job to `COMPLETED`; a closed, unmerged PR reconciles to `CANCELLED` and cannot launch queued work. The dashboard exposes `/api/jobs` and shows repository-wide managed PR state beside each durable Agents Relay job state so stale markers are visible instead of being mistaken for current truth.
 
-For work that was completed outside the relay but must be represented truthfully in durable history, use `npx agents-relay record --task-id <id> --summary <summary> --commit <sha>`. Recorded tasks use the `orchestrator` adapter and terminal `SUCCEEDED` state; they do not pretend a shell/model worker executed the work. This is a repair/backfill mechanism—normal work should be submitted before execution. Managed jobs also retain the GitHub PR body as the job description for dashboard display.
+For work that was completed outside the relay but must be represented truthfully in durable history, use `npx agents-relay record --task-id <id> --summary <summary> --commit <sha>`. Recorded tasks use the `orchestrator` adapter and terminal `SUCCEEDED` state; they do not pretend a shell/model worker executed the work. This is a repair/backfill mechanism—normal work should be created as a durable Task before execution. Managed jobs also retain the GitHub PR body as the job description for dashboard display.

package/dist/cli.js

@@ -14,12 +14,12 @@ import { NatsEventBus, eventFor } from './events.js';
 import { serveDashboard } from './dashboard.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { discoverAgents } from './registry.js';
-import { AgentObjectivePlanner, CommandObjectivePlanner, orchestratorPlanningDecision } from './planner.js';
+import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { extendRetryBudget, parseJobSchedule } from './scheduler.js';
 import { dueBuckets, processDueScheduledJobs, syncScheduleLabels } from './scheduled-jobs.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { defaultWorkspaceRoot, resolveManagedProjectPath } from './workspace.js';
-const usage = 'agents-relay <job|task|context|init|submit|record|agent-register|agent-discover|reconcile|tick|retry|cancel|serve> [options]';
+const usage = 'agents-relay <job|task|context|init|record|agent-register|agent-discover|reconcile|tick|serve> [options]';
 const help = {
     root: `Agents Relay coordinates durable asynchronous agent jobs through GitHub pull requests.
 
@@ -28,16 +28,14 @@ Usage:
 
 Commands:
   job create|update|show|list  Manage durable GitHub-backed jobs
-  task update              Update mutable durable task fields in place
+  task create|update|show|list|retry|cancel  Manage durable tasks
   context resolve          Resolve shared project instructions, skills, agents, and runtimes
   init                     Create a local demo job or initialize a GitHub job
-  submit                   Queue a task for a managed job
   record                   Backfill a completed task into durable history
   agent-register           Register an agent role and its capabilities
   agent-discover           Find registered agents matching hard filters
   reconcile                Run reconciliation once
   tick                     Run the indexed autonomous scheduler heartbeat
-  retry|cancel             Change a task state
   serve                    Run the dashboard and reconciliation service
 
 Run 'npx agents-relay <command> --help' for command options and examples.
@@ -89,21 +87,46 @@ Required: --repo OWNER/REPO.
 
 Example:
   npx agents-relay job list --repo OWNER/REPO`,
-    task: `Manage a durable task.
+    task: `Manage durable tasks.
 
 Usage:
-  npx agents-relay task update [options]
+  npx agents-relay task <create|update|show|list|retry|cancel> [options]
 
 Actions:
-  update  Update mutable task fields without changing task identity/history`,
-    'task update': `Update mutable durable task fields in place.
+  create  Create one executable Task under an existing Job
+  update  Update mutable Task fields
+  show    Show one Task
+  list    List Tasks for a Job
+  retry   Retry a failed or blocked Task
+  cancel  Cancel a Task`,
+    'task create': `Create one executable Task under an existing Job.
+
+Required: normal Job storage options plus --input TEXT and --output task-pr|file. Codex/ChatGPT tasks also require --model MODEL.
+Common: --task-id ID, --adapter codex|chatgpt|orchestrator, --priority P0|P1|P2|P3, --story-size S|M|L, --deps a,b, --parent ID.
+Directly-created Tasks are not wrapped in a synthetic Plan. Planner-generated Tasks are created internally by Relay from planner output.
 
-Required: --task-id ID and the normal job storage options.
+Example:
+  npx agents-relay task create --repo OWNER/REPO --pr 12 --id job-1 --task-id build --adapter codex --provider openai --model MODEL --output task-pr --input "Implement the requested change."`,
+    'task update': `Update mutable durable Task fields in place.
+
+Required: --task-id ID and the normal Job storage options.
 Mutable while not RUNNING/SUCCEEDED/CANCELLED: --adapter, --priority, --story-size, --input, --project, --agent, --parent, --deps, --capabilities, --timeout, --max-attempts, --provider, --model, --profile, --reasoning, --cwd, --chatgpt-project, --chatgpt-tab-close-policy.
-Use --clear-routing to remove routing metadata. A model update requires --model; provider defaults to the existing provider or openai.
+Use --clear-routing to remove routing metadata.
 
 Example:
   npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id build --adapter chatgpt --provider chatgpt --model gpt-5.6-sol --reasoning high`,
+    'task show': `Show one durable Task.
+
+Required: --task-id ID and the normal Job storage options.`,
+    'task list': `List durable Tasks for one Job.
+
+Required: the normal Job storage options.`,
+    'task retry': `Retry one durable Task.
+
+Required: --task-id ID and the normal Job storage options.`,
+    'task cancel': `Cancel one durable Task.
+
+Required: --task-id ID and the normal Job storage options.`,
     context: `Resolve the shared execution context used by XChat and Relay.
 
 Usage:
@@ -119,13 +142,6 @@ Root overrides for testing/configuration: --workspace-root PATH, --neo-root PATH
 
 Example:
   npx agents-relay context resolve --project-path ~/Workspace/agents-relay --role orchestrator`,
-    submit: `Queue a task for a managed job.
-
-Required: --repo OWNER/REPO, --pr NUMBER, --id JOB_ID, and --input TEXT.
-Required for worker tasks: --adapter codex|chatgpt|orchestrator and --output task-pr|file. Codex/ChatGPT also require --model MODEL. File output also requires --output-path PATH.\nCommon: --task-id ID, --priority P0|P1|P2|P3, --story-size S|M|L, --max-attempts N. Story size defaults to M. Task producers follow the shared Task / Job Contract; prefer --story-size over raw --timeout. Model-backed execution requires --events nats in the running reconciler/daemon.
-
-Example:
-  npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 --task-id build --adapter codex --provider openai --model gpt-5-6 --output task-pr --input "Run the required tests and report the result through events."`,
     record: `Backfill work completed outside the relay into durable history.
 
 Required: --file PATH or --repo/--pr/--id, plus --summary TEXT.
@@ -173,18 +189,6 @@ Common: --capabilities a,b, --runtime NAME, --availability available,busy, --tas
 
 Example:
   npx agents-relay agent-discover --file .agents-relay.json --capabilities shell`,
-    retry: `Retry a task by setting it READY.
-
-Required: --task-id ID and the normal job storage options.
-
-Example:
-  npx agents-relay retry --repo OWNER/REPO --pr 12 --id job-1 --task-id build`,
-    cancel: `Cancel a task.
-
-Required: --task-id ID and the normal job storage options.
-
-Example:
-  npx agents-relay cancel --repo OWNER/REPO --pr 12 --id job-1 --task-id build`
 };
 export function helpText(command, action) {
     if (command === 'job')
@@ -316,19 +320,6 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
         await syncScheduleLabels(client, repositoryName, job);
     return { job: await store.load(options.id), pr };
 }
-async function appendPlannedTask(store, job, task) {
-    const existing = job.tasks.find(item => item.id === task.id);
-    if (existing)
-        return existing;
-    const decisionId = `plan-${task.id}`;
-    const decision = orchestratorPlanningDecision(job, [task], decisionId, task.parentTaskId, job.tasks.filter(item => item.kind === 'planner').length, 'orchestrator');
-    if (!job.tasks.some(item => item.id === decision.id))
-        await store.appendTask(decision);
-    const planned = { ...task, parentTaskId: decision.id, planningDecisionId: decision.id, planningSource: 'orchestrator', planningRound: decision.planningRound };
-    await store.appendTask(planned);
-    job.tasks.push(planned, decision);
-    return planned;
-}
 function workerTaskFromArgs(job, args, now) {
     const model = arg(args, '--model');
     const adapterValue = arg(args, '--adapter');
@@ -336,12 +327,14 @@ function workerTaskFromArgs(job, args, now) {
     const outputKind = arg(args, '--output');
     const outputPath = arg(args, '--output-path');
     const input = arg(args, '--input');
+    if (!input)
+        throw new Error('task create requires --input');
     if (!['codex', 'chatgpt', 'orchestrator'].includes(adapter))
-        throw new Error('submit adapter must be codex, chatgpt, or orchestrator');
+        throw new Error('task create --adapter must be codex, chatgpt, or orchestrator');
     if (adapter !== 'orchestrator' && !model)
-        throw new Error('submit requires --model for codex/chatgpt tasks');
+        throw new Error('task create requires --model for codex/chatgpt tasks');
     if (outputKind !== 'task-pr' && outputKind !== 'file')
-        throw new Error('submit requires --output task-pr|file');
+        throw new Error('task create requires --output task-pr|file');
     if (outputKind === 'file' && !outputPath)
         throw new Error('--output file requires --output-path');
     const routing = adapter === 'orchestrator' ? 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 };
@@ -381,15 +374,57 @@ function workerTaskFromArgs(job, args, now) {
     };
 }
 async function runTaskCommand(action, args) {
-    if (action !== 'update')
+    if (!['create', 'update', 'show', 'list', 'retry', 'cancel'].includes(action))
         throw new Error(usage);
     const { store, job, localFile } = await storeFor(args);
-    const id = arg(args, '--task-id');
+    if (action === 'list') {
+        console.log(JSON.stringify(job.tasks, null, 2));
+        return;
+    }
+    const id = arg(args, '--task-id', action === 'create' ? randomUUID() : '');
     if (!id)
-        throw new Error('task update requires --task-id');
+        throw new Error(`task ${action} requires --task-id`);
+    if (action === 'create') {
+        const now = new Date().toISOString();
+        const task = workerTaskFromArgs(job, args, now);
+        task.id = id;
+        await store.appendTask(task);
+        const refreshed = await store.load(job.id);
+        if (refreshed.state !== 'RUNNING') {
+            refreshed.state = 'RUNNING';
+            refreshed.updatedAt = now;
+            await store.saveJob(refreshed);
+        }
+        const durableTask = (await store.load(job.id)).tasks.find(item => item.id === task.id) ?? task;
+        await saveLocal(localFile, await store.load(job.id));
+        await publishWake(eventBus(args), refreshed, task.id, `Task ${task.id} created`);
+        console.log(JSON.stringify(durableTask, null, 2));
+        return;
+    }
     const task = job.tasks.find(item => item.id === id);
     if (!task)
         throw new Error(`Task ${id} not found`);
+    if (action === 'show') {
+        console.log(JSON.stringify(task, null, 2));
+        return;
+    }
+    if (action === 'retry' || action === 'cancel') {
+        if (action === 'retry')
+            task.maxAttempts = extendRetryBudget(task);
+        task.state = action === 'retry' ? 'READY' : 'CANCELLED';
+        task.error = action === 'retry' ? null : 'Cancelled by user';
+        task.updatedAt = new Date().toISOString();
+        await store.saveTask(task);
+        if (action === 'retry' && job.state !== 'RUNNING') {
+            job.state = 'RUNNING';
+            job.updatedAt = task.updatedAt;
+            await store.saveJob(job);
+        }
+        await saveLocal(localFile, job);
+        await publishWake(eventBus(args), job, task.id, `${task.id} ${action} requested`);
+        console.log(JSON.stringify(task, null, 2));
+        return;
+    }
     if (['RUNNING', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
         throw new Error(`Task ${id} is ${task.state}; durable execution fields are immutable in this state`);
     if (hasArg(args, '--adapter')) {
@@ -438,8 +473,7 @@ async function runTaskCommand(action, args) {
             reasoning: hasArg(args, '--reasoning') ? arg(args, '--reasoning') || undefined : current?.reasoning,
             cwd: hasArg(args, '--cwd') ? arg(args, '--cwd') || undefined : current?.cwd,
             projectId: hasArg(args, '--chatgpt-project') ? arg(args, '--chatgpt-project') || undefined : current?.projectId,
-            decidedBy: 'cli:update',
-            decidedAt: new Date().toISOString()
+            decidedBy: 'cli:update', decidedAt: new Date().toISOString()
         };
         if (hasArg(args, '--reasoning') && !hasArg(args, '--timeout'))
             task.timeoutMs = taskOverallTimeoutMs(task.storySize ?? 'M', task.routing.reasoning);
@@ -714,51 +748,16 @@ async function main() {
             throw new Error('record requires --summary');
         const commit = arg(args, '--commit');
         const task = { jobId: job.id, 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 };
-        await appendPlannedTask(store, job, task);
+        await store.appendTask(task);
+        job.tasks.push(task);
         await saveLocal(localFile, job);
         console.log(`Recorded ${id}`);
         return;
     }
-    if (command === 'submit') {
-        const now = new Date().toISOString();
-        const task = workerTaskFromArgs(job, args, now);
-        task.id = arg(args, '--task-id', randomUUID());
-        const planned = await appendPlannedTask(store, job, task);
-        if (job.state !== 'RUNNING') {
-            job.state = 'RUNNING';
-            job.updatedAt = now;
-            await store.saveJob(job);
-        }
-        await saveLocal(localFile, job);
-        await publishWake(bus, job, planned.id, `Planning decision recorded and task ${planned.id} submitted`);
-        console.log(`Submitted ${planned.id}`);
-        return;
-    }
     if (command === 'status') {
         console.log(JSON.stringify(await store.load(job.id), null, 2));
         return;
     }
-    if (command === 'retry' || command === 'cancel') {
-        const id = arg(args, '--task-id');
-        const task = job.tasks.find(item => item.id === id);
-        if (!task)
-            throw new Error(`Task ${id} not found`);
-        if (command === 'retry')
-            task.maxAttempts = extendRetryBudget(task);
-        task.state = command === 'retry' ? 'READY' : 'CANCELLED';
-        task.error = command === 'retry' ? null : 'Cancelled by user';
-        task.updatedAt = new Date().toISOString();
-        await store.saveTask(task);
-        if (command === 'retry' && job.state !== 'RUNNING') {
-            job.state = 'RUNNING';
-            job.updatedAt = task.updatedAt;
-            await store.saveJob(job);
-        }
-        await saveLocal(localFile, job);
-        await publishWake(bus, job, task.id, `${task.id} ${command} requested`);
-        console.log(`${id}: ${task.state}`);
-        return;
-    }
     const reconciler = runtime(store, args, bus);
     if (command === 'reconcile') {
         await reconciler.reconcile(job.id);

package/dist/planner.js

@@ -11,10 +11,6 @@ export function planningSpec(task) {
         throw new Error(`Initial task ${task.id} requires a supported adapter`);
     return { id: task.id, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs };
 }
-export function orchestratorPlanningDecision(job, tasks, id, parentTaskId, round, source = 'orchestrator') {
-    const now = new Date().toISOString();
-    return { jobId: job.id, id, kind: 'planner', priority: job.priority, storySize: 'S', agentName: source === 'orchestrator' ? 'orchestrator' : 'planner', parentTaskId, dependencies: [], capabilities: ['planner'], adapter: 'orchestrator', input: `Planning decision supplied by ${source} for ${tasks.length} task(s)`, state: 'SUCCEEDED', attempt: 1, maxAttempts: 1, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: { summary: source === 'orchestrator' ? 'Initial task set supplied by orchestrator' : 'Planning decision completed' }, plannerResult: { objective_status: 'in_progress', assessment: source === 'orchestrator' ? 'Initial task set supplied by orchestrator' : 'Planning decision completed', next_tasks: tasks.map(planningSpec) }, error: null, timeoutMs: 0, createdAt: now, updatedAt: now, planningDecisionId: id, planningSource: source, planningRound: round };
-}
 function record(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error('Planner result must be an object');

package/dist/pool.js

@@ -4,7 +4,7 @@ const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export function runnableManagedJobs(items) { return items.filter(item => item.githubState === 'OPEN' && !item.draft && !['COMPLETED', 'CANCELLED'].includes(item.job.state)).map(item => item.job).sort(compareJobPriority); }
 export function needsLifecycleReconciliation(job, now = Date.now()) {
-    // Create-only jobs stay OPEN until a caller explicitly submits work.
+    // Create-only Jobs stay OPEN until a caller explicitly creates work.
     if (job.tasks.length === 0)
         return false;
     if (job.tasks.some(task => ['READY', 'QUEUED', 'WAITING'].includes(task.state)))

package/dist/reconciler.js

@@ -386,7 +386,7 @@ export class Reconciler {
         if (job.initialPlanning?.status === 'pending')
             return job;
         const allPlanners = job.tasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-        if (allPlanners.length === 0)
+        if (allPlanners.length === 0 && job.tasks.length === 0)
             return job;
         const slot = job.schedule?.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
         const scopedTasks = Number.isFinite(slot) ? job.tasks.filter(task => Date.parse(task.createdAt) >= slot) : job.tasks;
@@ -395,7 +395,7 @@ export class Reconciler {
             return job;
         if (scopedTasks.some(task => task.state === 'FAILED' || task.state === 'BLOCKED'))
             return job;
-        if (scopedTasks.length > 0 && !planners.some(task => task.state === 'SUCCEEDED'))
+        if (scopedTasks.length > 0 && planners.length > 0 && !planners.some(task => task.state === 'SUCCEEDED'))
             return job;
         if (scopedTasks.some(task => task.kind !== 'planner' && !['SUCCEEDED', 'CANCELLED'].includes(task.state)))
             return job;

package/dist/types.js

@@ -2,7 +2,7 @@ export const STORY_SIZE_TIMEOUT_MS = { S: 300000, M: 900000, L: 2700000 };
 export function storySizeTimeoutMs(size) { return STORY_SIZE_TIMEOUT_MS[size]; }
 export function taskOverallTimeoutMs(size, reasoning) { return storySizeTimeoutMs(size) * (reasoning?.toLowerCase() === 'high' ? 2 : 1); }
 export function chatGptStartAckTimeoutMs(overallTimeoutMs) { return Math.min(600000, Math.max(120000, Math.floor(overallTimeoutMs / 3))); }
-const jobTransitions = { OPEN: ['RUNNING', 'WAITING', 'BLOCKED', 'COMPLETED', 'CANCELLED'], RUNNING: ['OPEN', 'WAITING', 'BLOCKED', 'COMPLETED', 'FAILED', 'CANCELLED'], WAITING: ['RUNNING', 'BLOCKED', 'COMPLETED', 'CANCELLED'], BLOCKED: ['RUNNING', 'CANCELLED'], COMPLETED: ['RUNNING', 'CANCELLED'], FAILED: ['RUNNING', 'CANCELLED'], CANCELLED: ['RUNNING'] };
+const jobTransitions = { OPEN: ['RUNNING', 'WAITING', 'BLOCKED', 'COMPLETED', 'CANCELLED'], RUNNING: ['OPEN', 'WAITING', 'BLOCKED', 'COMPLETED', 'FAILED', 'CANCELLED'], WAITING: ['RUNNING', 'BLOCKED', 'COMPLETED', 'CANCELLED'], BLOCKED: ['RUNNING', 'COMPLETED', 'CANCELLED'], COMPLETED: ['RUNNING', 'CANCELLED'], FAILED: ['RUNNING', 'COMPLETED', 'CANCELLED'], CANCELLED: ['RUNNING', 'COMPLETED'] };
 const taskTransitions = { QUEUED: ['READY', 'BLOCKED', 'CANCELLED'], READY: ['RUNNING', 'BLOCKED', 'FAILED', 'CANCELLED'], RUNNING: ['WAITING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED', 'READY'], WAITING: ['READY', 'BLOCKED', 'CANCELLED'], BLOCKED: ['READY', 'CANCELLED'], SUCCEEDED: [], FAILED: ['READY', 'RUNNING', 'CANCELLED'], CANCELLED: [] };
 export function assertJobTransition(from, to) { if (from !== to && !jobTransitions[from].includes(to))
     throw new Error(`Invalid job transition ${from} -> ${to}`); }

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -62,7 +62,7 @@ Example:
 ~~~sh
 npx agents-relay job create --repo OWNER/REPO --head feat/example --base main   --id JOB_ID --title "Objective"
 
-npx agents-relay submit --repo OWNER/REPO --pr 12 --id JOB_ID   --task-id implement   --adapter codex   --provider openai --model MODEL   --output task-pr   --input "Implement the requested change, validate it, and update the managed task/PR."
+npx agents-relay task create --repo OWNER/REPO --pr 12 --id JOB_ID   --task-id implement   --adapter codex   --provider openai --model MODEL   --output task-pr   --input "Implement the requested change, validate it, and update the managed task/PR."
 
 npx agents-relayd --repo OWNER/REPO --events nats
 ~~~
@@ -96,17 +96,15 @@ ChatGPT thread identity is diagnostic only. It is not persisted as a resumable t
 
 ## Autonomous planner
 
-No executable task may be materialized without a completed durable planning
-decision. Job creation with caller-supplied initial work records an
-orchestrator-owned `planner-0` decision before its initial tasks; autonomous
-mode must not start a model planner in that case. Objective-only autonomous
-jobs may start a real model planner, and planner children are created only
-after that planner succeeds. Fixed jobs do not automatically create another
-planning round. Each task exposes `planningDecisionId`, `planningSource`, and
-`planningRound` for dashboard lineage. Nested worker delegation must create its
-durable planning decision and children through Relay as well.
-
-Planner-created child tasks must also be descriptive agent work. They must select `codex` or `chatgpt` and include an explicit output contract. A planner must never generate shell-command worker tasks.
+Direct orchestrator-created Tasks do not require a Plan. The orchestrator may create the initial batch with `task create`; those Tasks remain top-level unless the orchestrator explicitly gives them normal task parentage.
+
+For autonomous continuation, Relay invokes the planner agent as a pure decision function. The planner receives durable Job/Task state, previous planner rounds, and resolved execution context, then returns structured `{ objective_status, assessment, next_tasks }` output. The planner does not call Relay CLI and does not persist Tasks itself.
+
+Each successful planner invocation is one real planner round. Relay persists that planner result, then creates the returned Tasks with lineage back to that planner round. Only planner execution creates planner rounds; Relay never manufactures synthetic `plan-*` records for direct Task creation. In the dashboard, planner rounds are organizational/grouping nodes for the Tasks they produced.
+
+A zero-task autonomous Job remains idle. After a direct orchestrator-created initial batch completes, Relay may start the first real planner round. Fixed Jobs do not automatically create planner rounds.
+
+Planner-created child Tasks remain descriptive agent work and must include worker requirements, output contract, and `storySize`; worker-router/model-router choose execution routing afterward.
 
 ## Durable truth
 

package/skills/agents-relay/agents/planner.agent.md

@@ -4,22 +4,30 @@ You are the default objective planner for Agents Relay autonomous jobs.
 
 Before producing tasks, read and follow `../contracts/task-job-contract.md`.
 
-Inspect the durable objective and task tree, then decide whether the objective is satisfied or which descriptive agent tasks should run next.
+You are a pure planning agent. Relay invokes you with the durable Job, existing Tasks, previous planner rounds, and resolved project context. You return one structured planning result. You do not call the Agents Relay CLI, persist state, create Jobs, or mutate Tasks yourself.
+
+Relay persists each successful planner invocation as one planner round and creates the returned Tasks under that round.
 
 ## Rules
 
-- Treat durable job/task state as authoritative.
+- Treat durable Job/Task state as authoritative.
 - Never invent completed work or evidence.
-- Prefer small independently verifiable tasks.
-- Preserve parent/subtask causality and stable IDs.
-- A child task describes what an agent must accomplish. Never emit a shell command as a worker task.
-- Every child task must declare `workerRequirements` (capabilities plus any runtime, task-kind, trust-domain, region, or label constraints). The worker-router resolves those requirements against the fresh usage snapshot and available workers before model-router chooses provider/model details.
-- Do not choose `codex`/`chatgpt` or provider/model heuristically. When a selected worker is supplied by the caller, consume that selection; otherwise leave worker selection to the worker-router.
-- Every child task must declare exactly one output: `task_pr` or `file`.
-- Do not emit provider/model routing metadata; worker-router and model-router add it after planning.
-- Every child task must include `storySize` according to the shared Task / Job Contract. Use `M` when uncertain.
+- First decide whether the objective is already satisfied.
+- If satisfied, return `objective_status: "satisfied"` and `next_tasks: []`.
+- Otherwise return only the next useful executable batch.
+- Do not repeat completed work or recreate an existing Task unless replacement work is explicitly needed.
+- Prefer small independently verifiable Tasks with stable IDs.
+- A Task describes what an agent must accomplish; never emit a shell command as a worker Task.
+- Use dependencies only when execution order actually matters.
+- Every child Task must declare `workerRequirements`; worker-router selects the worker and model-router selects provider/model/reasoning afterward.
+- Do not choose `codex`/`chatgpt`, provider/model, or usage probes.
+- Every child Task must declare exactly one output: `task_pr` or `file`.
+- Every child Task must include `storySize` (`S`, `M`, or `L`); use `M` when uncertain.
+- Do not create bookkeeping, waiting, status-checking, wrapper, or planning Tasks. Your response itself is the planning round.
 - Return no prose outside the JSON result.
 
 ## Output
 
-Return exactly one JSON object with `objective_status`, `assessment`, and `next_tasks`. Each next task contains id, input, `workerRequirements`, output, and storySize. Adapter/routing fields are selected by the runtime after worker-router runs; do not invent them. Each task may also contain priority, projectName, agentName, dependencies, capabilities, maxAttempts, and timeoutMs. When the objective is satisfied, next_tasks must be empty.
+Return exactly one JSON object with `objective_status`, `assessment`, and `next_tasks`.
+
+Each item in `next_tasks` contains `id`, `input`, `workerRequirements`, `output`, and `storySize`. It may also contain priority, projectName, agentName, dependencies, capabilities, maxAttempts, and timeoutMs. Adapter/routing fields are selected by Relay after planning; do not invent them.

package/skills/agents-relay/contracts/orchestrator-workflows.md

@@ -20,7 +20,7 @@ A **P0 job** (alias: **self job**) is executed directly by the current active or
 1. The orchestrator creates the durable job.
 2. The orchestrator immediately creates the required orchestrator-owned task(s); do not leave the P0 job idle.
 3. The current orchestrator thread starts executing those tasks immediately rather than delegating them to another worker.
-4. After implementation, the orchestrator performs/reconciles review against the current head.
-5. If review passes and merge requirements are satisfied, the orchestrator merges the job itself and completes normal post-merge reconciliation.
+4. P0/self jobs do not require the normal reviewer gate unless the user explicitly asks for review.
+5. After implementation and local verification, the orchestrator merges the job itself and completes normal post-merge reconciliation.
 
 `job create` still only creates durable job state; the P0 workflow requires the orchestrator to follow it immediately with task creation and execution.

package/skills/agents-relay/contracts/task-job-contract.md

@@ -40,10 +40,19 @@ A normal task never merges a PR. After all non-superseded work gates pass, Relay
 
 Final-review routing follows the same worker-selection boundary as executable work. Capability, availability, explicit reviewer constraints, and resource health are hard gates. Among eligible workers, Relay prefers a reviewer with a different worker identity from the implementation tasks; when that is unavailable it prefers a different provider/model, then falls back to the first eligible worker. The selected worker, `selectedBy` reason, and `reviewerRouting` event data are durable evidence. No provider is a universal reviewer default.
 
-## Fixed and autonomous jobs
+## Job, Task, and planner ownership
 
-`job create` persists only the durable job. It never creates executable work. The top-level orchestrator owns the initial execution decision and, when the user intends the job to start, submits the first task batch separately. A zero-task autonomous job stays idle and reconciliation must not bootstrap its first planner.
+The public CLI resource surface is:
 
-`fixed` jobs execute the orchestrator-provided task set and then proceed to final review. Once an autonomous job has been explicitly started by an orchestrator-provided planning batch, it may ask the planner for additional task batches. Planner-produced tasks must obey this same contract, including explicit `storySize`.
+- `job create|update|show|list`
+- `task create|update|show|list|retry|cancel`
+
+`job create` persists only durable Job state. It never creates executable work. `task create` creates a real executable Task directly under the Job; direct orchestrator-created Tasks are not wrapped in synthetic planner Tasks and have no planner-round provenance.
+
+Planner rounds are internal planner output, not a general public CLI resource. Relay invokes the planner agent, validates its structured result, persists that invocation as one planner round, then materializes `next_tasks` under that planner round. The planner agent itself does not call Relay CLI or persist Tasks. Only an actual planner invocation creates a planner round.
+
+A zero-task autonomous Job stays idle. An autonomous Job may begin with one or more direct orchestrator-created Tasks and no Plan. After that direct batch completes, Relay may create the first real planner round. Later planner rounds continue until the objective is satisfied. Fixed Jobs never create autonomous planner rounds.
+
+Planner-produced Tasks obey this same contract, including explicit `storySize`.
 
 A scheduled autonomous job adds cron/timezone/next-run and missed-run/concurrency policy to the trusted job marker, plus the `agents-relay:autonomous` label and one bounded time-of-day `agents-relay:next-run:*` index label. The GitHub heartbeat discovers only indexed due candidates, validates the marker's exact `nextRunAt`, claims the slot idempotently, advances the durable next run, and pulses `agents-relay:schedule-wake`. GitHub webhook delivery then wakes local Relay for planner/worker execution. While the schedule is active, each satisfied run returns the job to `WAITING` instead of entering final-review/auto-merge; older-cycle failures are historical evidence and do not block a later slot.