agents-relay 1.0.30 → 1.0.32

package/dist/planner.js

@@ -3,6 +3,18 @@ import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { taskOverallTimeoutMs } from './types.js';
+import { executionContextPrompt } from './execution-context.js';
+export function planningSpec(task) {
+    if (!task.output && task.adapter !== 'orchestrator')
+        throw new Error(`Initial task ${task.id} requires an output contract`);
+    if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
+        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, 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');
@@ -111,7 +123,7 @@ export function parsePlannerOutput(output) {
     return parsePlannerResult(JSON.parse(candidate));
 }
 export function plannerInput(context) {
-    return JSON.stringify({ objective: context.objective, previous_planner_task_id: context.previousPlannerTaskId, tasks: context.tasks.map(task => ({ id: task.id, kind: task.kind ?? 'work', parent_task_id: task.parentTaskId, state: task.state, input: task.input, result: task.result, planner_result: task.plannerResult, error: task.error })) });
+    return JSON.stringify({ objective: context.objective, previous_planner_task_id: context.previousPlannerTaskId, execution_context: context.executionContext, tasks: context.tasks.map(task => ({ id: task.id, kind: task.kind ?? 'work', parent_task_id: task.parentTaskId, state: task.state, input: task.input, result: task.result, planner_result: task.plannerResult, error: task.error })) });
 }
 export class CommandObjectivePlanner {
     command;
@@ -162,9 +174,11 @@ export class AgentObjectivePlanner {
         this.agentFile = agentFile;
     }
     async plan(context, signal) {
-        const instructions = await readFile(this.agentFile, 'utf8');
+        const resolvedPlanner = context.executionContext?.agents.find(agent => agent.name === 'planner')?.path;
+        const instructions = await readFile(resolvedPlanner ?? this.agentFile, 'utf8');
         const contract = await readFile(DEFAULT_TASK_JOB_CONTRACT, 'utf8');
-        const prompt = instructions.trim() + '\n\n## Shared Task / Job Contract\n\n' + contract.trim() + '\n\n## Durable planner input\n\n' + plannerInput(context);
+        const resolvedContext = context.executionContext ? executionContextPrompt(context.executionContext) + '\n\n' : '';
+        const prompt = instructions.trim() + '\n\n## Shared Task / Job Contract\n\n' + contract.trim() + '\n\n' + resolvedContext + '## Durable planner input\n\n' + plannerInput(context);
         return await new Promise((resolve, reject) => {
             const child = spawn(this.command, ['exec', '--json', '--', prompt], { stdio: ['ignore', 'pipe', 'pipe'] });
             let stdoutBuffer = '';

package/dist/reconciler.js

@@ -4,9 +4,10 @@ import { schedule, transitionTask } from './scheduler.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
+import { executionContextPrompt, resolveExecutionContext } from './execution-context.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareTaskPriority(a, b, jobPriority = 'P2') { const ar = PRIORITY_RANK[a.priority ?? jobPriority]; const br = PRIORITY_RANK[b.priority ?? jobPriority]; return ar - br || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
-export function managedWorkerInput(job, task) {
+export function managedWorkerInput(job, task, context) {
     if (!['codex', 'chatgpt'].includes(task.adapter) || !job.repository || job.prNumber <= 0)
         return task.input;
     if (!task.output)
@@ -20,9 +21,9 @@ PR: ${prUrl}
 Job: ${job.id}
 Task: ${task.id}
 Parent task: ${task.parentTaskId ?? 'none'}
-Project: ${task.projectName ?? 'unspecified'}
+Project: ${task.projectName ?? context?.project.name ?? 'unspecified'}
 
-${task.input}
+${context ? executionContextPrompt(context) + '\n\n' : ''}${task.input}${task.parentTaskId ? '\n\n[Nested delegation contract]\nAny sub-work must be created as a durable Agents Relay child task with parentTaskId=' + task.id + '; do not directly spawn arbitrary child agents.' : ''}
 
 [Output contract]
 ${output}
@@ -125,12 +126,17 @@ export class Reconciler {
                 }
             }
             await this.recoverLostExecutions(job, now);
+            await this.recoverPlannerChildren(job);
             for (const task of job.tasks)
                 if (task.state === 'CANCELLED') {
                     this.live.get(task.id)?.execution.cancel();
                     this.plannerLive.get(task.id)?.controller.abort();
                 }
             let scheduled = schedule(await this.store.load(jobId));
+            if (prState === 'OPEN') {
+                await this.ensureFinalReview(scheduled, prState, headSha);
+                scheduled = schedule(await this.store.load(jobId));
+            }
             if (prState === 'OPEN' && scheduled.executionMode === 'autonomous') {
                 scheduled = schedule(await this.maybeCreatePlanner(scheduled));
             }
@@ -284,16 +290,24 @@ export class Reconciler {
     async maybeCreatePlanner(job) {
         if (job.executionMode !== 'autonomous')
             return job;
+        if (job.initialPlanning?.status === 'pending')
+            return job;
         const planners = job.tasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
         if (planners.some(task => ['QUEUED', 'READY', 'RUNNING', 'WAITING'].includes(task.state)))
             return job;
         if (job.tasks.some(task => task.state === 'FAILED' || task.state === 'BLOCKED'))
             return job;
+        if (job.tasks.length > 0 && !planners.some(task => task.state === 'SUCCEEDED'))
+            return job;
         if (job.tasks.some(task => task.kind !== 'planner' && !['SUCCEEDED', 'CANCELLED'].includes(task.state)))
             return job;
+        if (planners.length > 0 && planners.at(-1)?.plannerResult?.objective_status === 'in_progress' && !job.tasks.some(task => task.planningDecisionId === planners.at(-1)?.id))
+            return job;
         const latest = planners.at(-1);
         if (latest?.plannerResult?.objective_status === 'satisfied')
             return job;
+        if (latest && job.review && job.review.outcome !== 'approved')
+            return job;
         const used = new Set(job.tasks.map(task => task.id));
         let number = planners.length + 1;
         let id = `planner-${number}`;
@@ -302,11 +316,34 @@ export class Reconciler {
             id = `planner-${number}`;
         }
         const now = new Date().toISOString();
-        const task = { jobId: job.id, id, kind: 'planner', storySize: 'M', agentName: 'planner', parentTaskId: latest?.id ?? null, dependencies: [], capabilities: ['planner'], adapter: 'orchestrator', input: plannerInput({ job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: latest?.id ?? null }), continuation: null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
+        const task = { jobId: job.id, id, kind: 'planner', storySize: 'M', agentName: 'planner', parentTaskId: latest?.id ?? null, dependencies: [], capabilities: ['planner'], adapter: 'orchestrator', input: plannerInput({ job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: latest?.id ?? null }), continuation: null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now, planningDecisionId: id, planningSource: 'model-planner', planningRound: planners.length + 1 };
         await this.store.appendTask(task);
         await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.created', 'queued', `Planner task ${task.id} created`, 'orchestrator'));
         return this.store.load(job.id);
     }
+    async recoverPlannerChildren(job) {
+        for (const planner of job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult)) {
+            const children = planner.plannerResult?.next_tasks.map(spec => this.plannerChild(job, planner, spec)) ?? [];
+            for (const child of children) {
+                const existing = job.tasks.find(item => item.id === child.id);
+                if (existing) {
+                    if (!samePlannerChildDefinition(existing, child))
+                        throw new Error(`Planner task ${child.id} already exists with a different definition`);
+                    continue;
+                }
+                await this.store.appendTask(child);
+                job.tasks.push(child);
+            }
+        }
+    }
+    async resolvedContext(job, task, role) {
+        const projectPath = this.options.projectPathForJob ? await this.options.projectPathForJob(job) : task.routing?.cwd ?? process.cwd();
+        return resolveExecutionContext(projectPath, role, {
+            ...(this.options.executionContextRoots ?? {}),
+            registeredAgents: await this.store.listAgents(),
+            runtimes: this.options.adapters.map(adapter => ({ name: adapter.name, id: adapter.id, capabilities: [...adapter.capabilities] })),
+        });
+    }
     async launch(job, task) {
         const adapter = this.options.adapters.find(x => x.name === task.adapter);
         if (!adapter) {
@@ -322,8 +359,11 @@ export class Reconciler {
             return;
         }
         let workerInput;
+        let executionContext;
         try {
-            workerInput = managedWorkerInput(job, task);
+            const role = task.agentName === 'reviewer' ? 'reviewer' : task.parentTaskId ? 'nested-worker' : 'worker';
+            executionContext = await this.resolvedContext(job, task, role);
+            workerInput = managedWorkerInput(job, task, executionContext);
         }
         catch (error) {
             transitionTask(task, 'BLOCKED');
@@ -342,7 +382,7 @@ export class Reconciler {
         await this.store.saveTask(task);
         const controller = new AbortController();
         let execution;
-        const workerTask = { ...task, input: workerInput };
+        const workerTask = { ...task, input: workerInput, routing: task.routing ? { ...task.routing, cwd: task.routing.cwd ?? executionContext.project.path } : task.routing };
         const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, Date.now(), this.options.startAckTimeoutMs ?? chatGptStartAckTimeoutMs(task.timeoutMs)) : null;
         const closePolicy = task.chatgptTabClosePolicy ?? this.options.chatgptTabClosePolicy ?? adapter.tabClosePolicy ?? 'after-start';
         const terminalWait = task.adapter === 'chatgpt' && closePolicy === 'after-terminal'
@@ -351,6 +391,7 @@ export class Reconciler {
         const launchContext = {
             ...(startAckSetup ? { waitForWorkerStart: startAckSetup.ack } : {}),
             ...(terminalWait ? { waitForTerminal: terminalWait.promise } : {}),
+            executionContext,
         };
         try {
             execution = adapter.launch(workerTask, controller.signal, launchContext);
@@ -435,7 +476,8 @@ export class Reconciler {
         this.plannerLive.set(task.id, { executionId: executionId, controller, timer });
         let promise;
         try {
-            promise = planner.plan({ job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: task.parentTaskId }, controller.signal);
+            const executionContext = await this.resolvedContext(job, task, 'planner');
+            promise = planner.plan({ job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: task.parentTaskId, executionContext }, controller.signal);
         }
         catch (error) {
             await this.finishPlanner(job.id, task.id, executionId, error instanceof Error ? error : new Error(String(error)));
@@ -467,14 +509,15 @@ export class Reconciler {
         }
         try {
             const result = parsePlannerResult(raw);
-            for (const spec of result.next_tasks) {
-                const child = this.plannerChild(job, task, spec);
+            const children = result.next_tasks.map(spec => this.plannerChild(job, task, spec));
+            for (const child of children) {
                 const existing = job.tasks.find(item => item.id === child.id);
                 if (!existing)
-                    await this.store.appendTask(child);
+                    continue;
                 else if (!samePlannerChildDefinition(existing, child))
                     throw new Error(`Planner task ${child.id} already exists with a different definition`);
             }
+            // Persist the completed decision before exposing executable children.
             task.plannerResult = result;
             task.result = { summary: result.assessment, data: { objective_status: result.objective_status, next_tasks: result.next_tasks } };
             task.error = null;
@@ -482,22 +525,32 @@ export class Reconciler {
             task.leaseExpiresAt = null;
             transitionTask(task, 'SUCCEEDED');
             await this.store.saveTask(task);
+            for (const child of children)
+                if (!job.tasks.some(item => item.id === child.id))
+                    await this.store.appendTask(child);
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.completed', 'succeeded', `Planner ${task.id} completed: ${result.objective_status}`, 'orchestrator', { objective_status: result.objective_status }));
         }
         catch (caught) {
             const message = caught instanceof Error ? caught.message : String(caught);
-            task.error = message;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            transitionTask(task, task.attempt < task.maxAttempts ? 'READY' : 'FAILED');
-            await this.store.saveTask(task);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.failed', 'failed', `Planner ${task.id}: ${message}`, 'user'));
+            if (task.state === 'SUCCEEDED') {
+                task.error = `Child materialization failed: ${message}`;
+                await this.store.saveTask(task);
+                await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.children_failed', 'failed', `Planner ${task.id} child materialization failed: ${message}`, 'user'));
+            }
+            else {
+                task.error = message;
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+                transitionTask(task, task.attempt < task.maxAttempts ? 'READY' : 'FAILED');
+                await this.store.saveTask(task);
+                await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.failed', 'failed', `Planner ${task.id}: ${message}`, 'user'));
+            }
         }
         this.detach(this.reconcile(jobId), jobId, task.id, 'planner follow-up reconciliation');
     }
     plannerChild(job, planner, spec) {
         const now = new Date().toISOString();
-        return { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, parentTaskId: planner.id, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], adapter: spec.adapter, input: spec.input, output: spec.output, routing: spec.routing, continuation: spec.continuation ?? null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M', spec.routing?.reasoning), createdAt: now, updatedAt: now };
+        return { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, parentTaskId: planner.id, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], adapter: spec.adapter, input: spec.input, output: spec.output, routing: spec.routing, continuation: spec.continuation ?? null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M', spec.routing?.reasoning), createdAt: now, updatedAt: now, planningDecisionId: planner.id, planningSource: planner.planningSource ?? 'model-planner', planningRound: planner.planningRound ?? 1 };
     }
     clearExecution(taskId, executionId) {
         const live = this.live.get(taskId);

package/dist/relayd.js

@@ -13,7 +13,7 @@ import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPull
 import { githubAuthContext } from './github-auth.js';
 import { isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
-import { defaultWorkspaceRoot, discoverWorkspaceRepositories } from './workspace.js';
+import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath } from './workspace.js';
 export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
 
 Usage:
@@ -64,10 +64,12 @@ export async function runDaemon(argv) {
     const trusted = auth.trustedAuthors;
     const concurrency = Number(value(argv, '--concurrency', '4'));
     const bus = value(argv, '--events') === 'nats' ? new NatsEventBus(value(argv, '--nats-url', 'nats://127.0.0.1:4222'), value(argv, '--subject-prefix', 'neo.events.job')) : undefined;
-    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), eventBus: bus, reviewer: runtimeReviewer() });
-    const repositories = normalized.repository
-        ? [normalized.repository]
-        : (await discoverWorkspaceRepositories(normalized.workspaceRoot ?? defaultWorkspaceRoot())).map(item => item.repository);
+    const workspaceRoot = normalized.workspaceRoot ?? defaultWorkspaceRoot();
+    const discoveredRepositories = normalized.repository ? [] : await discoverWorkspaceRepositories(workspaceRoot);
+    const repositories = normalized.repository ? [normalized.repository] : discoveredRepositories.map(item => item.repository);
+    const repositoryPaths = new Map(discoveredRepositories.map(item => [item.repository, item.path]));
+    const explicitProjectPath = value(argv, '--project-path');
+    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
     const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler);

package/dist/store.js

@@ -82,7 +82,7 @@ function immutableTaskDefinition(task) {
     } : undefined;
     return {
         jobId: task.jobId, id: task.id, priority: task.priority, storySize: task.storySize ?? 'M', projectName: task.projectName, agentName: task.agentName,
-        kind: task.kind ?? 'work', parentTaskId: task.parentTaskId, dependencies: task.dependencies, capabilities: task.capabilities, adapter: task.adapter,
+        kind: task.kind ?? 'work', planningDecisionId: task.planningDecisionId, planningSource: task.planningSource, planningRound: task.planningRound, parentTaskId: task.parentTaskId, dependencies: task.dependencies, capabilities: task.capabilities, adapter: task.adapter,
         input: task.input, output: task.output, routing, chatgptTabClosePolicy: task.chatgptTabClosePolicy ?? 'after-start', continuation: task.continuation ?? null, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs
     };
 }

package/dist/workspace.js

@@ -64,6 +64,17 @@ export async function discoverWorkspaceRepositories(root) {
     }
     return [...unique.values()].sort((a, b) => a.repository.localeCompare(b.repository));
 }
+export async function resolveWorkspaceRepositoryPath(repository, root = defaultWorkspaceRoot()) {
+    const match = (await discoverWorkspaceRepositories(root)).find(item => item.repository === repository);
+    if (!match)
+        throw new Error(`Repository ${repository} not found under workspace ${resolve(root)}; pass --project-path explicitly`);
+    return match.path;
+}
+export async function resolveManagedProjectPath(repository, explicitProjectPath = '', root = defaultWorkspaceRoot(), cwd = process.cwd()) {
+    if (explicitProjectPath)
+        return resolve(explicitProjectPath);
+    return repository ? resolveWorkspaceRepositoryPath(repository, root) : resolve(cwd);
+}
 function repositoryPathRank(path, root) {
     const relativePath = relative(root, path);
     if (!relativePath.includes('/'))

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -82,14 +82,30 @@ For Codex and ChatGPT workers, Agents Relay adds only durable execution identity
 
 The job/task descriptions remain the durable source of intent. Adapters do not invent task meaning.
 
+## Shared execution context
+
+Before planner, reviewer, normal worker, or nested-worker execution, resolve one execution context from the bound project path. The shared resolver owns project instructions, skills, visible agents, and runtime capabilities with project-local > Neo shared > global `~/.agents` precedence. Concrete paths are execution-time data and must not be persisted into durable task records.
+
+Leaf workers consume the resolved instruction/skill/agent paths, not the full top-level XChat orchestrator contract. Nested workers may inspect visible agents, but any delegation must be represented as an Agents Relay durable child task preserving `parentTaskId`, output contract, routing, leases/retries, events, and review gates.
+
 ## ChatGPT worker
 
-The ChatGPT adapter uses the packaged `chatgpt-browser-worker` one-shot path. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
+The ChatGPT adapter uses the `chatgpt-browser-worker` path from the shared execution context; Relay does not bundle or independently rediscover that skill. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
 
 ChatGPT thread identity is diagnostic only. It is not persisted as a resumable task handle, and Relay does not poll, resume, retrieve a result from, or delete a ChatGPT conversation as part of task lifecycle.
 
 ## 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.
 
 ## Durable truth

package/skills/chatgpt-browser-worker/SKILL.md

@@ -1,67 +0,0 @@
----
-name: chatgpt-browser-worker
-description: Submit an isolated one-shot ChatGPT browser worker task through browser-harness with a required durable output destination.
----
-
-# ChatGPT browser worker
-
-Use this skill to hand one self-contained task to ChatGPT through the authenticated
-browser session. The caller does not manage ChatGPT threads, model selection,
-thinking level, polling, or result retrieval.
-
-## Output contract
-
-Every task handed to this worker MUST declare exactly one durable output mode
-before the worker is launched.
-
-### 1. Task / PR output
-
-Use this for repository or managed-task work.
-
-The task prompt must identify the exact managed task/PR that owns the result.
-The worker performs the requested work directly against that task/PR and records
-its final outcome there.
-
-Output:
-task/PR
-<exact managed task/PR identity and required final action>
-
-### 2. File output
-
-Use this for research, analysis, reports, or other artifact-producing work.
-
-The task prompt must name the exact file path. That file is the authoritative
-result.
-
-Output:
-file
-<exact file path>
-
-A Browser ChatGPT worker task without one of these output declarations is
-invalid and must not be launched. The orchestrator chooses and writes the output
-contract when it creates the worker task; the worker must not invent or change
-the destination.
-
-Progress and terminal success/failure are always reported through the normal
-Neo event contract. Events are execution observability, not a third output mode.
-
-## Runtime behavior
-
-The worker is one-shot. It opens an isolated worker-owned ChatGPT tab, submits
-the complete task, verifies that ChatGPT accepted the submission, and applies
-the configured tab-close policy. `after-start` waits for the exact
-post-submission worker `task.started` acknowledgement, `never` leaves the owned
-tab open for debugging, and `after-terminal` waits for a new exact-task
-`task.completed`, `task.failed`, `task.blocked`, or `task.cancelled` event.
-ChatGPT continues the task independently and publishes the result through the
-declared output contract. If the start acknowledgement does not arrive within
-60 seconds, close only the owned tab and fail with `worker_start_timeout`.
-
-The worker must never interact through a pre-existing user ChatGPT tab.
-Browser details, transient conversation identity, submission verification,
-model/default-thinking behavior, and tab cleanup are implementation concerns of
-the worker and are not part of the caller-facing contract.
-
-The runtime entry point is the browser-worker agent. Callers launch that agent
-with the complete task prompt and declared output; they do not call helper
-scripts directly.

package/skills/chatgpt-browser-worker/agents/browser-worker.agent.md

@@ -1,47 +0,0 @@
----
-name: browser-worker
-description: Submit one isolated ChatGPT browser task and return after the task is accepted.
-type: worker
----
-
-# Browser Worker Agent
-
-You are the runtime owner for the `chatgpt-browser-worker` skill. Load and follow
-that skill and the `browser-harness` skill before execution.
-
-The outer orchestrator gives you one complete task. That task MUST already
-contain exactly one output declaration defined by the skill:
-
-- `task/PR` with the exact managed task/PR identity and required final action; or
-- `file` with the exact authoritative output path.
-
-If the output declaration is missing or ambiguous, do not invent one.
-
-## Runtime rules
-
-- Use `browser-harness` for every ChatGPT browser interaction.
-- Execute only a one-shot submission. Do not expose or operate a
-  create/resume/status/result/continue lifecycle for callers.
-- Always create a fresh worker-owned tab. Never type, upload, click New chat,
-  select a Project, or submit through a pre-existing user ChatGPT tab.
-- Use Temporary Chat and the account's existing default model/thinking
-  settings. Do not change model or thinking settings.
-- Upload requested files, submit the complete task prompt, and verify that the
-  submission became a new user turn.
-- Once submission is verified, follow the configured owned-tab close policy:
-  `after-start` closes after a new worker-owned `task.started` event, `never`
-  leaves the owned tab open for test/debug use, and `after-terminal` closes only
-  after a new exact-task `task.completed`, `task.failed`, `task.blocked`, or
-  `task.cancelled` event. Never close a user tab. Do not wait for the assistant
-  response or reopen/poll the conversation. If the start acknowledgement does
-  not arrive within 60 seconds, close only the owned tab and report a timeout.
-- Treat any observed conversation/thread identity only as diagnostic evidence,
-  never as a resumable handle.
-- Progress and terminal success/failure for the actual delegated task are
-  reported through the normal Neo event contract by the executing task. The
-  final durable result goes to the declared task/PR or file output.
-- Stop on authentication, MFA, consent, or ambiguous browser state rather than
-  bypassing it.
-
-Helper scripts under `scripts/` are implementation details. Callers must not
-invoke them directly.

package/skills/chatgpt-browser-worker/scripts/_submit_readiness.py

@@ -1,30 +0,0 @@
-"""Bounded polling helpers for ChatGPT submit readiness."""
-from __future__ import annotations
-
-import time
-from collections.abc import Callable, Mapping
-
-
-def wait_until_stable(
-    read_state: Callable[[], Mapping[str, object]],
-    ready: Callable[[Mapping[str, object]], bool],
-    *,
-    timeout: float,
-    interval: float = 0.25,
-    stable_samples: int = 2,
-    phase: str,
-) -> Mapping[str, object]:
-    """Return only after the observable state is ready for stable_samples polls."""
-    deadline = time.monotonic() + timeout
-    stable = 0
-    last_state: Mapping[str, object] = {}
-    while time.monotonic() < deadline:
-        last_state = read_state()
-        if ready(last_state):
-            stable += 1
-            if stable >= stable_samples:
-                return last_state
-        else:
-            stable = 0
-        time.sleep(interval)
-    raise RuntimeError(f"Temporary Chat {phase} was not observed ready")