agents-relay 1.0.30 → 1.0.31

package/README.md

@@ -93,6 +93,14 @@ V1 assumes one active runner/daemon per job. Use a distributed atomic lease befo
 
 Codex/model-backed tasks require --provider and --model (or equivalent routing metadata) before launch. See [docs/architecture.md](docs/architecture.md) and [skills/agents-relay/SKILL.md](skills/agents-relay/SKILL.md).
 
+XChat and other orchestrators can consume Relay's exact shared discovery implementation without duplicating filesystem search logic:
+
+~~~sh
+npx agents-relay context resolve --project-path ~/Workspace/agents-relay --role orchestrator
+~~~
+
+The command resolves concrete paths only for the current execution. Use `--skills` / `--agents` for explicit selections; no resolved absolute path is written into durable task state.
+
 The minimal agent-network surface is machine-driven registration and discovery. `agent-register` persists an agent identity, responsibility boundary, claimed capabilities, endpoint/runtime, availability, and routing metadata in a trusted PR marker; `agent-discover` applies hard filters and returns evidence-backed candidates. Adapters remain runtimes, not agent identities. See [docs/architecture.md](docs/architecture.md) for the constrained future remote submission contract.
 
 ### Agent worker lifecycle
@@ -103,7 +111,7 @@ Every model-backed task declares a durable output with `--output task-pr` or `--
 
 For Codex and ChatGPT, **events are authoritative task state**. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay only subscribes and reconciles. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab after 60 seconds. The executing agent must publish exactly one correlated terminal event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
 
-The ChatGPT adapter uses the packaged `chatgpt-browser-worker` as a one-shot submitter. 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.
+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 \

package/dist/adapters.js

@@ -1,8 +1,6 @@
 import { spawn } from 'node:child_process';
 import { access, readFile, writeFile, unlink } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
@@ -108,33 +106,18 @@ export class LaunchFailure extends Error {
 }
 export class StartAckTimeout extends LaunchFailure {
 }
-function browserWorkerCandidates(explicit) {
-    const roots = (process.env.AGENTS_RELAY_SKILL_ROOTS ?? '').split(':').filter(Boolean);
-    const packageSkills = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills');
-    return [
-        explicit,
-        ...roots,
-        packageSkills,
-        join(homedir(), '.codex', 'skills'),
-        join(homedir(), '.agents', 'skills'),
-        join(process.cwd(), 'skills'),
-    ]
-        .filter((value) => Boolean(value))
-        .map(value => value.endsWith('browser-worker.agent.md')
-        ? value
-        : join(value, 'chatgpt-browser-worker', 'agents', 'browser-worker.agent.md'));
-}
-async function loadBrowserWorkerRuntime(explicit) {
-    for (const candidate of browserWorkerCandidates(explicit)) {
-        try {
-            await access(candidate);
-            return { definition: await readFile(candidate, 'utf8'), root: dirname(dirname(candidate)) };
-        }
-        catch {
-            // Try the next installed skill root.
-        }
+async function loadBrowserWorkerRuntime(context, explicit) {
+    const resolvedSkill = context?.skills.find(skill => skill.name === 'chatgpt-browser-worker');
+    const candidate = explicit ?? (resolvedSkill ? join(dirname(resolvedSkill.path), 'agents', 'browser-worker.agent.md') : undefined);
+    if (!candidate)
+        throw new Error('chatgpt-browser-worker is not visible in the resolved execution context');
+    try {
+        await access(candidate);
+        return { definition: await readFile(candidate, 'utf8'), root: dirname(dirname(candidate)) };
+    }
+    catch {
+        throw new Error(`chatgpt-browser-worker agent definition not found at resolved path: ${candidate}`);
     }
-    throw new Error('chatgpt-browser-worker agent definition not found; set AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT');
 }
 function parseDriverJson(output) {
     const lines = output.trim().split(/\r?\n/).filter(Boolean);
@@ -260,7 +243,7 @@ export class ChatGptAdapter {
         execution.launched = new Promise((resolve, reject) => { launchResolve = resolve; launchReject = reject; });
         execution.launched.catch(() => { });
         execution.promise = (async () => {
-            const runtime = await loadBrowserWorkerRuntime(this.agentPath);
+            const runtime = await loadBrowserWorkerRuntime(context.executionContext, this.agentPath);
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);

package/dist/cli.js

@@ -16,7 +16,9 @@ import { codexAndZaiUsageRegistry } from './usage.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { extendRetryBudget } from './scheduler.js';
-const usage = 'agents-relay <job|task|init|submit|record|agent-register|agent-discover|status|reconcile|retry|cancel|serve> [options]';
+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|status|reconcile|retry|cancel|serve> [options]';
 const help = {
     root: `Agents Relay coordinates durable asynchronous agent jobs through GitHub pull requests.
 
@@ -26,6 +28,7 @@ Usage:
 Commands:
   job create|adopt|repair  Create or repair a durable GitHub-backed job
   task update              Update mutable durable task fields in place
+  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
@@ -96,6 +99,21 @@ Use --clear-routing to remove routing metadata. A model update requires --model;
 
 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`,
+    context: `Resolve the shared execution context used by XChat and Relay.
+
+Usage:
+  npx agents-relay context resolve --project-path PATH --role ROLE [options]
+
+Actions:
+  resolve  Resolve instructions, visible skills/agents, and runtime/delegation metadata`,
+    'context resolve': `Resolve shared execution context without creating durable state.
+
+Required: --project-path PATH.
+Common: --role orchestrator|planner|reviewer|worker|nested-worker, --skills a,b, --agents a,b.
+Root overrides for testing/configuration: --workspace-root PATH, --neo-root PATH|none, --global-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.
@@ -167,6 +185,8 @@ export function helpText(command, action) {
         return action ? help[`job ${action}`] ?? help.job : help.job;
     if (command === 'task')
         return action ? help[`task ${action}`] ?? help.task : help.task;
+    if (command === 'context')
+        return action ? help[`context ${action}`] ?? help.context : help.context;
     return command ? help[command] ?? help.root : help.root;
 }
 export const SERVICE_DEFAULTS = { port: 8787, watchdogMs: 300000, webhookWatchdogMs: 1800000, dashboardRefreshMs: 300000 };
@@ -390,6 +410,26 @@ async function runTaskCommand(action, args) {
     await saveLocal(localFile, job);
     console.log(JSON.stringify(task, null, 2));
 }
+async function runContextCommand(action, args) {
+    if (action !== 'resolve')
+        throw new Error(usage);
+    const projectPath = arg(args, '--project-path');
+    if (!projectPath)
+        throw new Error('context resolve requires --project-path');
+    const roleValue = arg(args, '--role', 'orchestrator');
+    const roles = ['orchestrator', 'planner', 'reviewer', 'worker', 'nested-worker'];
+    if (!roles.includes(roleValue))
+        throw new Error('--role must be orchestrator, planner, reviewer, worker, or nested-worker');
+    const neoRootArg = arg(args, '--neo-root');
+    const context = await resolveExecutionContext(projectPath, roleValue, {
+        workspaceRoot: arg(args, '--workspace-root') || undefined,
+        neoRoot: neoRootArg === 'none' ? null : neoRootArg || undefined,
+        globalRoot: arg(args, '--global-root') || undefined,
+        explicitSkills: arg(args, '--skills').split(',').filter(Boolean),
+        explicitAgents: arg(args, '--agents').split(',').filter(Boolean),
+    });
+    console.log(JSON.stringify(context, null, 2));
+}
 async function runJobCommand(action, args) {
     if (!['create', 'adopt', 'repair'].includes(action))
         throw new Error(usage);
@@ -441,7 +481,7 @@ async function runJobCommand(action, args) {
 }
 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 runtimeReviewer() { return { adapter: 'chatgpt', routing: { provider: 'chatgpt', model: 'account-defaults', decidedBy: 'fixed-chatgpt-reviewer', decidedAt: new Date().toISOString() } }; }
-export function runtime(store, args, bus) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy }); }
+export function runtime(store, args, bus) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: job => resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()) }); }
 export async function createService(args) {
     const loaded = await storeFor(args);
     const upstream = eventBus(args);
@@ -519,7 +559,7 @@ async function main() {
         return;
     }
     if (args.includes('--help') || args.includes('-h')) {
-        console.log(helpText(command, command === 'job' || command === 'task' ? args[0] : undefined));
+        console.log(helpText(command, command === 'job' || command === 'task' || command === 'context' ? args[0] : undefined));
         return;
     }
     if (command === 'job') {
@@ -532,6 +572,11 @@ async function main() {
         await runTaskCommand(action ?? '', taskArgs);
         return;
     }
+    if (command === 'context') {
+        const [action, ...contextArgs] = args;
+        await runContextCommand(action ?? '', contextArgs);
+        return;
+    }
     if (command === 'init') {
         const now = new Date().toISOString();
         const job = { id: arg(args, '--id', randomUUID()), title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), autoMerge: !hasArg(args, '--no-auto-merge'), prNumber: Number(arg(args, '--pr', '0')), repository: arg(args, '--repo'), state: 'OPEN', continuation: continuation(args), createdAt: now, updatedAt: now, tasks: [] };

package/dist/execution-context.js

@@ -0,0 +1,258 @@
+import { access, readFile, readdir, realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWithin(path, root) {
+    const value = relative(root, path);
+    return value === '' || (!value.startsWith('..' + sep) && value !== '..' && !isAbsolute(value));
+}
+async function directory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function configuredWorkspaceRoot(projectPath, explicit) {
+    const configured = explicit ?? process.env.AGENTS_RELAY_WORKSPACE_ROOT ?? process.env.XCHAT_WORKSPACE_ROOT;
+    if (configured)
+        return resolve(configured);
+    const conventional = join(homedir(), 'Workspace');
+    return isWithin(projectPath, conventional) ? conventional : dirname(projectPath);
+}
+async function configuredNeoRoot(workspaceRoot, explicit) {
+    if (explicit === null)
+        return null;
+    const configured = explicit ?? process.env.NEO_SHARED_ROOT;
+    if (configured)
+        return await directory(resolve(configured)) ? await realpath(resolve(configured)) : null;
+    const candidate = join(workspaceRoot, 'neo');
+    return await directory(candidate) ? await realpath(candidate) : null;
+}
+function configuredGlobalRoot(explicit) {
+    return resolve(explicit ?? process.env.AGENTS_HOME ?? join(homedir(), '.agents'));
+}
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        return {};
+    const end = content.indexOf('\n---', 4);
+    if (end < 0)
+        return {};
+    const result = {};
+    for (const line of content.slice(4, end).split(/\r?\n/)) {
+        const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        result[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return result;
+}
+function listValue(value) {
+    if (!value)
+        return [];
+    const trimmed = value.trim();
+    const body = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
+    return body.split(/[|,]/).map(item => item.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean);
+}
+async function metadata(path) {
+    const content = await readFile(path, 'utf8');
+    return { fields: parseFrontmatter(content), content };
+}
+async function instructionPaths(projectPath, workspaceRoot, neoRoot, globalRoot) {
+    const found = [];
+    const add = async (path, source) => {
+        if (await exists(path)) {
+            const concrete = await realpath(path);
+            if (!found.some(item => item.path === concrete))
+                found.push({ path: concrete, source });
+        }
+    };
+    await add(join(globalRoot, 'AGENTS.md'), 'global');
+    if (isWithin(projectPath, workspaceRoot)) {
+        const segments = relative(workspaceRoot, projectPath).split(sep).filter(Boolean);
+        let cursor = workspaceRoot;
+        await add(join(cursor, 'AGENTS.md'), neoRoot && isWithin(cursor, neoRoot) ? 'neo' : 'project');
+        for (const segment of segments) {
+            cursor = join(cursor, segment);
+            const source = neoRoot && isWithin(cursor, neoRoot) && !isWithin(cursor, projectPath) ? 'neo' : 'project';
+            await add(join(cursor, 'AGENTS.md'), source);
+        }
+    }
+    else {
+        await add(join(projectPath, 'AGENTS.md'), 'project');
+    }
+    await add(join(projectPath, 'README.md'), 'project');
+    return found;
+}
+async function skillLayer(root, source) {
+    const skillsRoot = join(root, 'skills');
+    let entries;
+    try {
+        entries = await readdir(skillsRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const path = join(skillsRoot, entry.name, 'SKILL.md');
+        if (!await exists(path))
+            continue;
+        const { fields } = await metadata(path);
+        result.push({ name: fields.name || entry.name, path: await realpath(path), source, description: fields.description || undefined });
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function agentFiles(root, source, skills) {
+    const candidates = [];
+    const skillDirs = skills.filter(skill => skill.source === source).map(skill => dirname(skill.path));
+    for (const skillDir of skillDirs) {
+        let entries;
+        try {
+            entries = await readdir(join(skillDir, 'agents'), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries)
+            if (entry.isFile() && entry.name.endsWith('.md'))
+                candidates.push(join(skillDir, 'agents', entry.name));
+    }
+    let direct;
+    try {
+        direct = await readdir(join(root, 'agents'), { withFileTypes: true });
+    }
+    catch {
+        direct = [];
+    }
+    for (const entry of direct)
+        if (entry.isFile() && entry.name.endsWith('.md'))
+            candidates.push(join(root, 'agents', entry.name));
+    const result = [];
+    for (const path of candidates) {
+        const { fields } = await metadata(path);
+        result.push({
+            name: fields.name || basename(path).replace(/\.agent\.md$/i, '').replace(/\.md$/i, ''),
+            path: await realpath(path),
+            source,
+            description: fields.description || undefined,
+            capabilities: listValue(fields.capabilities),
+            runtime: fields.runtime || listValue(fields.runtimes)[0] || undefined,
+            trustDomains: listValue(fields.trustDomains ?? fields.trust_domains ?? fields.trust),
+            delegation: listValue(fields.delegation),
+            restrictions: listValue(fields.restrictions ?? fields.boundaries),
+        });
+    }
+    return result;
+}
+function selectByName(items, explicit, kind) {
+    if (!explicit?.length)
+        return [...items];
+    const selected = explicit.map(name => {
+        const item = items.find(candidate => candidate.name === name);
+        if (!item)
+            throw new Error(`Explicit ${kind} ${name} is not visible in the resolved execution context`);
+        return item;
+    });
+    return selected;
+}
+export async function resolveExecutionContext(projectPath, role, options = {}) {
+    if (!projectPath)
+        throw new Error('projectPath is required');
+    const project = await realpath(resolve(projectPath)).catch(() => { throw new Error(`Project path not found: ${projectPath}`); });
+    if (!await directory(project))
+        throw new Error(`Project path is not a directory: ${projectPath}`);
+    const workspaceCandidate = configuredWorkspaceRoot(project, options.workspaceRoot);
+    const workspaceRoot = await realpath(workspaceCandidate).catch(() => workspaceCandidate);
+    const neoRoot = await configuredNeoRoot(workspaceRoot, options.neoRoot);
+    const globalCandidate = configuredGlobalRoot(options.globalRoot);
+    const globalRoot = await realpath(globalCandidate).catch(() => globalCandidate);
+    const layerRoots = [
+        { root: globalRoot, source: 'global' },
+        ...(neoRoot ? [{ root: neoRoot, source: 'neo' }] : []),
+        { root: project, source: 'project' },
+    ];
+    const uniqueLayers = layerRoots.filter((layer, index, list) => list.findIndex(item => resolve(item.root) === resolve(layer.root)) === index);
+    const skillMap = new Map();
+    const skillsByLayer = new Map();
+    for (const layer of uniqueLayers) {
+        const layerSkills = await skillLayer(layer.root, layer.source);
+        skillsByLayer.set(layer.root, layerSkills);
+        for (const skill of layerSkills)
+            skillMap.set(skill.name, skill);
+    }
+    const skills = selectByName([...skillMap.values()].sort((a, b) => a.name.localeCompare(b.name)), options.explicitSkills, 'skill');
+    const agentMap = new Map();
+    for (const layer of uniqueLayers) {
+        for (const agent of await agentFiles(layer.root, layer.source, skillsByLayer.get(layer.root) ?? []))
+            agentMap.set(agent.name, agent);
+    }
+    for (const registration of options.registeredAgents ?? []) {
+        if (agentMap.has(registration.name))
+            continue;
+        agentMap.set(registration.name, {
+            name: registration.name,
+            source: 'registry',
+            description: registration.responsibility,
+            capabilities: [...registration.capabilities],
+            runtime: registration.runtime.adapter,
+            trustDomains: [...(registration.routing.trustDomains ?? [])],
+            delegation: [],
+            restrictions: [...registration.boundaries],
+            registration,
+        });
+    }
+    const agents = selectByName([...agentMap.values()].sort((a, b) => a.name.localeCompare(b.name)), options.explicitAgents, 'agent');
+    return {
+        project: { name: basename(project), path: project, workspaceRoot, neoRoot, globalRoot },
+        role,
+        instructions: await instructionPaths(project, workspaceRoot, neoRoot, globalRoot),
+        skills,
+        agents,
+        runtimes: (options.runtimes ?? []).map(runtime => ({ name: runtime.name ?? runtime.adapter ?? 'unknown', id: runtime.id, capabilities: [...runtime.capabilities], source: 'runtime' })),
+        delegation: { mode: 'relay-child-task', parentTaskIdRequired: role === 'nested-worker' },
+    };
+}
+export function executionContextPrompt(context) {
+    const instructions = context.instructions.map(item => `- ${item.path} [${item.source}]`).join('\n') || '- none';
+    const skills = context.skills.map(item => `- ${item.name}: ${item.path} [${item.source}]`).join('\n') || '- none';
+    const agents = context.agents.map(item => {
+        const details = [
+            item.capabilities.length ? `capabilities=${item.capabilities.join(',')}` : '',
+            item.runtime ? `runtime=${item.runtime}` : '',
+            item.trustDomains.length ? `trust=${item.trustDomains.join(',')}` : '',
+            item.restrictions.length ? `restrictions=${item.restrictions.join(' | ')}` : '',
+        ].filter(Boolean).join('; ');
+        return `- ${item.name}${item.path ? `: ${item.path}` : ''} [${item.source}]${details ? ` — ${details}` : ''}`;
+    }).join('\n') || '- none';
+    const runtimes = context.runtimes.map(item => `- ${item.name}${item.id ? ` (${item.id})` : ''}: ${item.capabilities.join(',')}`).join('\n') || '- none';
+    return `[Resolved execution context]
+Role: ${context.role}
+Project path: ${context.project.path}
+
+Instructions (read in listed order; later/project-local instructions override earlier shared defaults):
+${instructions}
+
+Visible skills (already de-duplicated with project-local > Neo shared > global precedence):
+${skills}
+
+Visible agents:
+${agents}
+
+Runtime capabilities:
+${runtimes}
+
+Delegation contract:
+Nested work MUST be created as an Agents Relay durable child task with parentTaskId lineage. Do not directly spawn arbitrary child agents. Leaf workers do not inherit top-level XChat orchestration duties merely because xchat-orchestrator is visible.`;
+}

package/dist/planner.js

@@ -3,6 +3,7 @@ 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';
 function record(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error('Planner result must be an object');
@@ -111,7 +112,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 +163,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}
@@ -307,6 +308,14 @@ export class Reconciler {
         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 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 +331,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 +354,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 +363,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 +448,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)));

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/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.31",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {

package/skills/agents-relay/SKILL.md

@@ -82,9 +82,15 @@ 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.
 

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")

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

@@ -1,298 +0,0 @@
-import atexit
-import json
-import os
-import re
-import time
-
-from browser_harness import *
-
-
-CFG = json.load(open("__CFG_PATH__", encoding="utf-8"))
-_OWNED_TABS = []
-_KEEP_OWNED_TAB_OPEN = CFG.get("close_policy", "after-start") == "never"
-
-
-def _new_owned_tab(url):
-    target_id = cdp("Target.createTarget", url="about:blank", background=True)["targetId"]
-    switch_tab(target_id)
-    _OWNED_TABS.append(target_id)
-    if url != "about:blank":
-        goto_url(url)
-    return target_id
-
-
-def _close_owned_tabs():
-    if _KEEP_OWNED_TAB_OPEN:
-        return
-    while _OWNED_TABS:
-        try:
-            close_tab(_OWNED_TABS.pop())
-        except Exception:
-            pass
-
-
-atexit.register(_close_owned_tabs)
-
-
-def _composer():
-    selector = js("""(() => {
-      const preferred = document.querySelector('#prompt-textarea');
-      if (preferred) {
-        const r=preferred.getBoundingClientRect();
-        if (r.width>0 && r.height>0) return '#prompt-textarea';
-      }
-      const fallback = [...document.querySelectorAll('textarea,[contenteditable="true"]')]
-        .find(e => { const r=e.getBoundingClientRect(); return r.width>0 && r.height>0 && !e.disabled; });
-      if (!fallback) return null;
-      return fallback.tagName === 'TEXTAREA' ? 'textarea' : '[contenteditable="true"]';
-    })()""")
-    if not selector:
-        raise RuntimeError("Temporary Chat composer was not observed")
-    return selector
-
-
-def _composer_text(selector):
-    return js(f"""(() => {{
-      const e=document.querySelector({json.dumps(selector)});
-      return e ? ((e.innerText ?? e.value) || '') : '';
-    }})()""") or ""
-
-
-def _wait_for_composer(timeout=30):
-    def read_selector():
-        try:
-            return _composer()
-        except RuntimeError:
-            return None
-
-    return wait_until_stable(
-        lambda: {"selector": read_selector()},
-        lambda state: bool(state["selector"]),
-        timeout=timeout,
-        phase="composer readiness",
-    )["selector"]
-
-
-def _same_text(observed, expected):
-    normalize = lambda value: re.sub(r"\\s+", " ", value or "").strip()
-    return normalize(expected) in normalize(observed)
-
-
-def _normalized_text(value):
-    return re.sub(r"\s+", " ", value or "").strip()
-
-
-def _attachment_names():
-    return js(r"""(() => [...document.querySelectorAll('button[aria-label^="Remove file"]')]
-      .map(b => (b.getAttribute('aria-label') || '').replace(/^Remove file\s+\d+:\s*/, ''))
-      .filter(Boolean))()""") or []
-
-
-def _attachment_state():
-    return js(r"""(() => {
-      const names = [...document.querySelectorAll('button[aria-label^="Remove file"]')]
-        .map(b => (b.getAttribute('aria-label') || '').replace(/^Remove file\s+\d+:\s*/, ''))
-        .filter(Boolean);
-      const pending = [...document.querySelectorAll(
-        '[role="progressbar"], [aria-busy="true"], [data-state="loading"]'
-      )].some(e => {
-        const r=e.getBoundingClientRect();
-        return r.width > 0 && r.height > 0;
-      });
-      return {names, pending};
-    })()""") or {"names": [], "pending": True}
-
-
-def _send_state():
-    return js(r"""(() => {
-      const b=document.querySelector('button[data-testid="send-button"],button[aria-label="Send prompt"]');
-      return {present: !!b, enabled: !!b && !b.disabled && b.getAttribute('aria-disabled') !== 'true'};
-    })()""") or {"present": False, "enabled": False}
-
-
-def _wait_for_attachments(expected, timeout=45):
-    expected = set(expected)
-    wait_until_stable(
-        _attachment_state,
-        lambda state: expected.issubset(state["names"]) and not state["pending"],
-        timeout=timeout,
-        phase="attachment upload readiness",
-    )
-
-
-def _upload_files(paths):
-    if not paths:
-        return []
-    selector = js("""(() => {
-      for (const s of ['#upload-files','#upload-media','input[name="upload-media"]','input[type="file"]'])
-        if (document.querySelector(s)) return s;
-      return null;
-    })()""")
-    if not selector:
-        raise RuntimeError("ChatGPT file input was not observed")
-    for path in paths:
-        if not os.path.isfile(path):
-            raise RuntimeError(f"attachment does not exist: {path}")
-        upload_file(selector, path)
-    expected = [os.path.basename(path) for path in paths]
-    if expected:
-        # Presence is a selection signal; upload readiness is checked separately.
-        wait_until_stable(
-            _attachment_state,
-            lambda state: set(expected).issubset(state["names"]),
-            timeout=30,
-            phase="attachment presence",
-        )
-        _wait_for_attachments(expected)
-    return expected
-
-
-def _user_turns():
-    return js("""(() => [...document.querySelectorAll('[data-message-author-role="user"]')]
-      .map(e => ({text:e.innerText.trim(), id:e.getAttribute('data-message-id') || ''}))
-      .filter(e => e.text))()""") or []
-
-
-def _click_send():
-    ok = js("""(() => {
-      const b=document.querySelector('button[data-testid="send-button"],button[aria-label="Send prompt"]');
-      if (!b || b.disabled || b.getAttribute('aria-disabled') === 'true') return false;
-      b.click(); return true;
-    })()""")
-    if not ok:
-        raise RuntimeError("Temporary Chat send readiness changed before click")
-
-
-def _wait_for_send_ready(selector, prompt, attachments):
-    expected = set(attachments)
-
-    def read_state():
-        return {
-            "text": _composer_text(selector),
-            "attachments": _attachment_state(),
-            "send": _send_state(),
-        }
-
-    wait_until_stable(
-        read_state,
-        lambda state: (
-            _normalized_text(prompt) in _normalized_text(state["text"])
-            and expected.issubset(state["attachments"]["names"])
-            and not state["attachments"]["pending"]
-            and state["send"]["enabled"]
-        ),
-        timeout=45 if expected else 15,
-        phase="send readiness",
-    )
-
-
-def _wait_user_turn(before_count, prompt, timeout=20):
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        turns = _user_turns()
-        for turn in turns[before_count:]:
-            if _normalized_text(prompt) in _normalized_text(turn["text"]):
-                return turn
-        time.sleep(.25)
-    raise RuntimeError("Temporary Chat submission verification did not observe a new user turn")
-
-
-def _diagnostic_thread_id():
-    match = re.search(r"/c/([^/?#]+)", page_info().get("url", ""))
-    return match.group(1) if match else None
-
-
-_new_owned_tab("https://chatgpt.com/")
-wait_for_load()
-
-enabled = js("""(() => {
-  const matches=[...document.querySelectorAll('button')].filter(
-    b => (b.getAttribute('aria-label') || '').trim() === 'Temporary chat'
-  );
-  if (matches.length !== 1) return false;
-  matches[0].click();
-  return true;
-})()""")
-if not enabled:
-    raise RuntimeError("Temporary Chat toggle was not uniquely observed")
-
-deadline = time.time() + 20
-while time.time() < deadline:
-    if "temporary-chat=true" in page_info().get("url", ""):
-        try:
-            break
-        except RuntimeError:
-            pass
-    time.sleep(.25)
-else:
-    raise RuntimeError("Temporary Chat composer readiness was not observed")
-
-attachments = _upload_files(CFG.get("file", []))
-selector = _wait_for_composer()
-before_count = len(_user_turns())
-prompt = CFG["prompt"]
-is_contenteditable = bool(js(f"""(() => {{
-  const e=document.querySelector({json.dumps(selector)});
-  return !!e && e.getAttribute('contenteditable') === 'true';
-}})()"""))
-if is_contenteditable:
-    cleared = js(f"""(() => {{
-      const e=document.querySelector({json.dumps(selector)});
-      if (!e) return false;
-      e.focus();
-      const sel=window.getSelection();
-      const range=document.createRange();
-      range.selectNodeContents(e);
-      sel.removeAllRanges();
-      sel.addRange(range);
-      document.execCommand('delete', false, null);
-      return true;
-    }})()""")
-    if not cleared:
-        raise RuntimeError("Temporary Chat contenteditable composer could not be cleared")
-    for offset in range(0, len(prompt), 256):
-        chunk = prompt[offset:offset + 256]
-        inserted = js(f"""(() => {{
-          const e=document.querySelector({json.dumps(selector)});
-          if (!e) return false;
-          e.focus();
-          const ok=document.execCommand('insertText', false, {json.dumps(chunk)});
-          e.dispatchEvent(new InputEvent('input', {{bubbles:true,inputType:'insertText',data:{json.dumps(chunk)}}}));
-          return ok;
-        }})()""")
-        if not inserted:
-            raise RuntimeError(f"Temporary Chat composer rejected prompt chunk at offset {offset}")
-else:
-    fill_input(selector, prompt, clear_first=True)
-
-wait_until_stable(
-    lambda: {"text": _composer_text(selector)},
-    lambda state: _normalized_text(CFG["prompt"]) in _normalized_text(state["text"]),
-    timeout=30,
-    phase="composer readiness",
-)
-
-_wait_for_send_ready(selector, CFG["prompt"], attachments)
-_click_send()
-user_turn = _wait_user_turn(before_count, CFG["prompt"])
-
-print(json.dumps({
-    "operation": "submit",
-    "status": "submitted",
-    "temporary": True,
-    "attachments": attachments,
-    "diagnostic_thread_id": _diagnostic_thread_id(),
-    "user_message_id": user_turn.get("id") or None,
-    "verified": True,
-}, ensure_ascii=False), flush=True)
-
-# Keep the owned Temporary Chat tab alive until Relay observes the worker's
-# post-launch task.started acknowledgement.  The parent releases this file;
-# atexit then closes only this worker-owned tab.
-release_file = CFG.get("release_file")
-if not release_file:
-    raise RuntimeError("worker release file was not configured")
-if CFG.get("close_policy", "after-start") == "never":
-    raise SystemExit(0)
-while not os.path.exists(release_file):
-    time.sleep(.1)

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

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-"""Submit one isolated Temporary Chat task through browser-harness."""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import subprocess
-import tempfile
-
-
-BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_temporary_bh.py")
-READINESS_HELPER = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_submit_readiness.py")
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--prompt", required=True)
-    parser.add_argument("--file", action="append", default=[])
-    parser.add_argument("--release-file", required=True)
-    parser.add_argument("--close-policy", choices=["after-start", "never", "after-terminal"], default="after-start")
-    args = parser.parse_args()
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as handle:
-        json.dump(vars(args), handle, ensure_ascii=False)
-        config_path = handle.name
-    try:
-        helper = open(READINESS_HELPER, encoding="utf-8").read()
-        code = helper + "\n" + open(BH_SCRIPT, encoding="utf-8").read()
-        code = code.replace("__CFG_PATH__", config_path)
-        return subprocess.run(["browser-harness"], input=code, text=True, timeout=180).returncode
-    finally:
-        os.unlink(config_path)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())