agents-relay 2.0.65 → 2.0.66

package/README.md

@@ -151,6 +151,22 @@ Use `job update` for partial mutable metadata changes on an already healthy Job
 npx agents-relay job update --repo OWNER/REPO --pr 6 --id job-6 --priority P0 --no-auto-merge
 ~~~
 
+Request an eligible new review with `npx agents-relay review request --repo OWNER/REPO --pr NUMBER --id JOB_ID`.
+Pass optional `--thread-id THREAD_ID` to persist a reviewer-thread override for subsequent
+review routing. Without it, Relay uses the stored reviewer thread, then creator thread,
+or the legacy review path when neither exists. This request wakes graph-owned
+review orchestration; it is not a delivery receipt.
+
+Review destinations are durable Job facts. `job create` and `job update` accept
+`--reviewer-thread-id` and `--creator-thread-id`; a reviewer ID takes precedence
+over the creator/origin ID. A local runtime invocation may pass
+`--thread-id` as an explicit one-run review override. When a destination exists,
+final-review routing requires a ChatGPT/browser-workspace worker and submits the
+review request as a verified `new-turn` to that existing thread with the Job ID,
+PR number, and immutable review head SHA. Failure still follows the ordinary
+review task retry/recovery path; a transport failure is never treated as
+review delivery.
+
 `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 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.

package/dist/adapters.js

@@ -122,7 +122,7 @@ function findSubmittedReceipt(value) {
     if (!value || typeof value !== 'object')
         return undefined;
     const record = value;
-    if (record.operation === 'submit' && record.status === 'submitted')
+    if ((record.operation === 'submit' || record.operation === 'new-turn' || record.mode === 'new-turn') && record.status === 'submitted')
         return record;
     for (const key of ['result', 'output', 'data', 'stdout']) {
         const nested = findSubmittedReceipt(record[key]);
@@ -200,13 +200,64 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-async function runBrowserWorker(cli, configFile, signal) {
+/**
+ * The upstream new-turn action accepts idempotency_key but does not enforce it.
+ * Inspect the current thread before resubmitting after an ambiguous exit.
+ * If the transcript is not observable, fail closed rather than duplicate.
+ */
+async function findExistingReviewTurn(cli, sessionId, delivery, signal) {
+    const pathname = delivery.projectId
+        ? `/g/${encodeURIComponent(delivery.projectId)}/c/${encodeURIComponent(delivery.threadId)}`
+        : `/c/${encodeURIComponent(delivery.threadId)}`;
+    const marker = `Relay delivery ID: ${delivery.requestId}`;
+    const inspectJs = `(() => {
+    const legacy = [...document.querySelectorAll('[data-message-author-role="user"]')]
+      .map(e => ({text: (e.innerText || '').trim(), id: e.getAttribute('data-message-id') || ''})).filter(x => x.text);
+    if (legacy.length) return legacy;
+    return [...document.querySelectorAll('h4')].filter(e => (e.innerText || '').trim() === 'You said:')
+      .map((e,i) => ({text: (e.parentElement?.innerText || '').trim(), id: 'dom-user-' + i})).filter(x => x.text);
+  })()`;
+    const script = [
+        'import json, time',
+        'from urllib.parse import urlsplit',
+        `url = ${JSON.stringify(`https://chatgpt.com${pathname}`)}`,
+        `marker = ${JSON.stringify(marker)}`,
+        'goto_url(url)',
+        'wait_for_load()',
+        'if urlsplit(page_info().get("url", "")).path.rstrip("/") != urlsplit(url).path.rstrip("/"): raise RuntimeError("review thread redirect mismatch")',
+        'turns = []',
+        'for attempt in range(30):',
+        `    turns = js(${JSON.stringify(inspectJs)}) or []`,
+        '    if turns: break',
+        '    time.sleep(0.5)',
+        'if not turns: raise RuntimeError("review thread transcript unavailable; refusing ambiguous resubmission")',
+        'matches = [turn for turn in turns if marker in turn.get("text", "")]',
+        'if len(matches) > 1: raise RuntimeError("duplicate review delivery detected; manual reconciliation required")',
+        'print(json.dumps({"found": bool(matches), "user_message_id": matches[0].get("id") if matches else None}), flush=True)',
+    ].join('\n');
+    const envelope = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'exec', sessionId], script, signal));
+    if (envelope.ok !== true || typeof envelope.stdout !== 'string')
+        throw new Error('review thread inspection returned no executable result');
+    const observation = parseWorkspaceJson(envelope.stdout);
+    if (typeof observation.found !== 'boolean')
+        throw new Error('review thread inspection returned no authoritative result');
+    if (!observation.found)
+        return null;
+    return { status: 'submitted', mode: 'new-turn', thread_id: delivery.threadId, project_id: delivery.projectId,
+        verified_by: 'existing-user-turn', user_message_id: typeof observation.user_message_id === 'string' ? observation.user_message_id : null };
+}
+async function runBrowserWorker(cli, configFile, signal, action = 'temporary-submit', delivery) {
     const session = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'start'], undefined, signal));
     const sessionId = session.session_id;
     if (typeof sessionId !== 'string' || !sessionId)
         throw new Error('browser-workspace session start returned no session_id');
     try {
-        return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', 'temporary-submit', '--session-id', sessionId, '--config', configFile], undefined, signal);
+        if (delivery) {
+            const existing = await findExistingReviewTurn(cli, sessionId, delivery, signal);
+            if (existing)
+                return JSON.stringify(existing);
+        }
+        return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', action, '--session-id', sessionId, '--config', configFile], undefined, signal);
     }
     finally {
         await browserWorkspaceCommand(cli, ['session', 'stop', sessionId]).catch(() => { });
@@ -218,13 +269,20 @@ function browserWorkerRunner() {
         const promise = (async () => {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
-                await writeFile(configFile, JSON.stringify({
+                const delivery = request.thread;
+                await writeFile(configFile, JSON.stringify(delivery ? {
+                    project_id: delivery.projectId ?? _route.projectId ?? null,
+                    thread_id: delivery.threadId,
+                    message: `${request.prompt}\n\nRelay delivery ID: ${delivery.requestId}`,
+                    idempotency_key: delivery.requestId,
+                } : {
                     prompt: request.prompt,
                     file: request.files ?? [],
                 }));
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const output = await runBrowserWorker(cli, configFile, signal);
+                const action = delivery ? 'new-turn' : 'temporary-submit';
+                const output = await runBrowserWorker(cli, configFile, signal, action, delivery);
                 return JSON.stringify(parseDriverJson(output));
             }
             finally {
@@ -246,11 +304,10 @@ function parseBrowserWorkerResponse(output) {
     if (!value || typeof value !== 'object')
         throw new Error('browser-worker returned an invalid JSON response');
     const response = value;
-    if (response.operation !== 'submit' || response.status !== 'submitted') {
+    const verified = response.verified === true || response.verified_by !== undefined;
+    if (response.status !== 'submitted' || !verified) {
         throw new Error('browser-worker did not return a submitted receipt');
     }
-    if (response.verified !== true)
-        throw new Error('browser-worker submission was not verified');
     return response;
 }
 export class ChatGptAdapter {
@@ -287,10 +344,19 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? browserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? browserWorkerRunner())(definition, {
+                prompt: task.input,
+                ...(task.attachments?.length ? { files: task.attachments } : {}),
+                ...(task.chatgptThreadDelivery ? { thread: task.chatgptThreadDelivery } : {}),
+                tabClosePolicy: policy,
+            }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);
+                if (task.chatgptThreadDelivery && (typeof response.thread_id !== 'string' || response.thread_id !== task.chatgptThreadDelivery.threadId)) {
+                    throw new Error('browser-worker submitted to an unexpected ChatGPT thread');
+                }
+                execution.deliveryReceipt = { ...response };
                 launchResolve();
                 if (policy === 'after-start' && context.waitForWorkerStart)
                     await context.waitForWorkerStart;
@@ -307,6 +373,8 @@ export class ChatGptAdapter {
                     summary: 'ChatGPT task submitted; terminal task state is event-owned',
                     data: {
                         submitted: true,
+                        mode: response.mode ?? 'temporary-submit',
+                        threadId: response.thread_id ?? response.diagnostic_thread_id ?? null,
                         diagnosticThreadId: response.diagnostic_thread_id ?? null,
                         userMessageId: response.user_message_id ?? null,
                         verifiedBy: response.verified_by ?? null,

package/dist/cli-help.js

@@ -1,4 +1,4 @@
-export const usage = 'agents-relay <job|task|plan|blocker|projection|escalation|context|init|record|agent-register|agent-discover|status|reconcile|serve> [options]';
+export const usage = 'agents-relay <job|task|review|plan|blocker|projection|escalation|context|init|record|agent-register|agent-discover|status|reconcile|serve> [options]';
 const help = {
     root: `Agents Relay coordinates durable asynchronous agent jobs through GitHub pull requests.
 
@@ -8,6 +8,7 @@ Usage:
 Commands:
   job create|update|show|list|merge|unblock|cancel  Manage durable GitHub-backed jobs
   task create|update|show|list|complete|retry|unblock|cancel  Manage durable tasks
+  review request           Request graph-owned review (optional thread override)
   plan                     Invoke the Planner for an existing managed Job
   blocker add|resolve|show  Manage cross-Job blocker dependencies
   projection conflicts|resolve  Inspect and repair deterministic GitHub projection conflicts
@@ -44,11 +45,20 @@ Common options:
 
 Example:
   npx agents-relay job show --repo OWNER/REPO --pr 12 --id job-1`,
+    review: `Request a new SHA-bound reviewer turn through the existing Relay lifecycle.
+
+Usage: npx agents-relay review request --repo OWNER/REPO --pr NUMBER --id JOB_ID [--thread-id THREAD_ID]
+
+When provided, --thread-id persists a reviewer destination; otherwise the Job reviewer thread, then creator thread, then legacy review route is used. The command wakes Relay. Review Task creation, idempotency, routing and delivery remain graph/daemon-owned. Rejects in-flight/queued reviews; does not itself mark review delivered.`,
+    'review request': `Request a review in an existing ChatGPT thread.
+
+Required: --repo OWNER/REPO --pr NUMBER --id JOB_ID.
+Optional: --thread-id THREAD_ID persists a reviewer override; omitted uses Job reviewer/creator thread or legacy route. Rejects pending reviews and wakes managed reconciliation.`,
     'job create': `Create a durable Job and its trusted marker.
 
 Required: --repo OWNER/REPO, --id JOB_ID, and either --head BRANCH or --pr NUMBER.
 With --head, reuse/create the PR for that head. With --pr, bind an existing unmanaged PR.
-Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --no-review, --tag JSON. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
+Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --no-review, --tag JSON, --reviewer-thread-id ID, --creator-thread-id ID. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
 Job creation always enables auto-merge and never creates executable tasks. The orchestrator decides the initial task batch separately. Re-running create against an already healthy Job is idempotent and does not mutate its metadata.
 
 Example:
@@ -56,7 +66,7 @@ Example:
     'job update': `Partially update mutable metadata on a healthy existing Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
-Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, --project-path RELATIVE_PATH, --priority, --mode fixed|autonomous, --schedule, --tag JSON, --auto-merge|--no-auto-merge, --review|--no-review, and continuation options. Updating the objective also updates the PR body.
+Mutable: --title, --objective-file PATH|- (preferred) or --objective MARKDOWN, --project-path RELATIVE_PATH, --priority, --mode fixed|autonomous, --schedule, --tag JSON, --auto-merge|--no-auto-merge, --review|--no-review, --reviewer-thread-id ID, --creator-thread-id ID, and continuation options. Updating the objective also updates the PR body.
 Unspecified fields are preserved. Marker/binding corruption is never repaired implicitly; update fails with a precise diagnostic instead.
 
 Example:
@@ -185,7 +195,7 @@ Example:
 
 Required: --file PATH for local demo mode, or --repo OWNER/REPO --pr NUMBER --id JOB_ID.
 
-Managed GitHub jobs are reconciled by agents-relayd. The CLI publishes a job.wake request and does not launch workers; NATS is auto-detected when reachable; use --events nats to require it explicitly.
+Managed GitHub jobs are reconciled by agents-relayd. The CLI publishes a job.wake request and does not launch workers; NATS is auto-detected when reachable; use --events nats to require it explicitly. Local/runtime invocations may use --thread-id ID to override the durable reviewer/creator thread for ChatGPT review delivery.
 
 Example:
   npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1`,
@@ -198,7 +208,7 @@ Example:
     serve: `Run the dashboard and reconciliation service for a managed job.
 
 Required: --file PATH for local demo mode, or --repo OWNER/REPO --pr NUMBER --id JOB_ID.
-Common: --port PORT, --interval MS, --events nats (optional; reachable NATS is auto-detected).
+Common: --port PORT, --interval MS, --events nats (optional; reachable NATS is auto-detected), --thread-id ID (reviewer-thread override).
 
 Example:
   npx agents-relay serve --repo OWNER/REPO --pr 12 --id job-1`,

package/dist/cli-review.js

@@ -0,0 +1,35 @@
+import { storeFor, arg, hasArg, withEventBus, requestManagedReconciliation } from './cli-support.js';
+import { normalizeThreadId, resolveReviewerThreadDestination } from './reviewer-thread.js';
+export function reviewRequestThreadOverride(args) {
+    const values = [...args];
+    return hasArg(values, '--thread-id')
+        ? normalizeThreadId(arg(values, '--thread-id'), '--thread-id')
+        : undefined;
+}
+export async function runReviewCommand(action, reviewArgs) {
+    if (action !== 'request')
+        throw new Error('review supports: request');
+    if (!arg(reviewArgs, '--repo') || !arg(reviewArgs, '--pr') || !arg(reviewArgs, '--id'))
+        throw new Error('review request requires --repo, --pr and --id');
+    const threadId = reviewRequestThreadOverride(reviewArgs);
+    const { store, job, localFile } = await storeFor(reviewArgs);
+    if (localFile)
+        throw new Error('review request requires a managed GitHub Job');
+    if (job.state === 'CANCELLED' || job.state === 'COMPLETED')
+        throw new Error('Cannot request review for terminal Job');
+    if (!job.reviewEnabled)
+        throw new Error('Review disabled for this Job');
+    if (job.tasks.some(task => task.agentName === 'reviewer' && ['RUNNING', 'QUEUED', 'DRAFT'].includes(task.state)))
+        throw new Error('Review already queued or running; refusing duplicate request');
+    if (job.review?.outcome === 'approved')
+        throw new Error('Current head already approved; review request not needed');
+    if (threadId !== undefined) {
+        job.reviewerThreadId = threadId;
+        job.updatedAt = new Date().toISOString();
+        await store.saveJob(job);
+    }
+    const destination = resolveReviewerThreadDestination(job);
+    await withEventBus(reviewArgs, async (bus) => requestManagedReconciliation(bus, job));
+    console.log(JSON.stringify({ jobId: job.id, pr: job.prNumber, reviewerThreadId: destination?.threadId ?? null, status: 'requested', note: 'Relay graph will create the review Task once eligible; this is not a delivery receipt.' }, null, 2));
+    return;
+}

package/dist/cli.js

@@ -32,6 +32,9 @@ import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js
 import { runCliEntrypoint } from './cli-shutdown.js';
 import { shutdownOwnedProcesses } from './owned-process.js';
 export { helpText } from './cli-help.js';
+import { runReviewCommand } from './cli-review.js';
+import { normalizeThreadId, runtimeReviewer } from './reviewer-thread.js';
+export { runtimeReviewer } from './reviewer-thread.js';
 import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, withEventBus } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
 export async function ensureManagedGitHubJob(client, repositoryName, trustedAuthors, options) {
@@ -59,6 +62,8 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
         tag: options.tag,
         autoMerge: true,
         reviewEnabled: options.reviewEnabled ?? true,
+        ...(options.reviewerThreadId ? { reviewerThreadId: normalizeThreadId(options.reviewerThreadId, 'reviewer thread ID') } : {}),
+        ...(options.creatorThreadId ? { creatorThreadId: normalizeThreadId(options.creatorThreadId, 'creator thread ID') } : {}),
         prNumber: pr.number,
         repository: repositoryName,
         continuation: options.continuation ?? null,
@@ -390,6 +395,8 @@ async function runJobCommand(action, args) {
             tag: jobTagFromArgs(args),
             reviewEnabled: !hasArg(args, '--no-review'),
             continuation: continuation(args),
+            ...(hasArg(args, '--reviewer-thread-id') ? { reviewerThreadId: arg(args, '--reviewer-thread-id') } : {}),
+            ...(hasArg(args, '--creator-thread-id') ? { creatorThreadId: arg(args, '--creator-thread-id') } : {}),
             prNumber,
             head: arg(args, '--head') || undefined,
             base: arg(args, '--base', 'main'),
@@ -459,6 +466,10 @@ async function runJobCommand(action, args) {
         job.reviewEnabled = true;
     if (hasArg(args, '--no-review'))
         job.reviewEnabled = false;
+    if (hasArg(args, '--reviewer-thread-id'))
+        job.reviewerThreadId = normalizeThreadId(arg(args, '--reviewer-thread-id'), '--reviewer-thread-id');
+    if (hasArg(args, '--creator-thread-id'))
+        job.creatorThreadId = normalizeThreadId(arg(args, '--creator-thread-id'), '--creator-thread-id');
     if (hasArg(args, '--continue-kind') || hasArg(args, '--continue-target')) {
         const next = continuation(args);
         if (!next)
@@ -470,8 +481,7 @@ async function runJobCommand(action, args) {
     console.log(JSON.stringify(await store.load(id), null, 2));
 }
 export function runtimePlanner(args) { const plannerCommand = arg([...args], '--planner-command'); const modelRuntime = arg([...args], '--codex', 'codex'); return plannerCommand ? new CommandObjectivePlanner(plannerCommand) : new AgentObjectivePlanner(modelRuntime); }
-export function runtimeReviewer() { return { requirements: { capabilities: ['model'] } }; }
-export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: async (job) => resolveRepositoryProjectPath(await resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()), job.projectPath) }); }
+export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(args), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: async (job) => resolveRepositoryProjectPath(await resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()), job.projectPath) }); }
 export function dashboardJobAction(store, reconciler, action) {
     return async (jobId) => {
         const job = await store.load(jobId);
@@ -572,7 +582,7 @@ async function main() {
         return;
     }
     if (args.includes('--help') || args.includes('-h')) {
-        console.log(helpText(command, command === 'job' || command === 'task' || command === 'context' ? args[0] : undefined));
+        console.log(helpText(command, command === 'job' || command === 'task' || command === 'context' || command === 'review' ? args[0] : undefined));
         return;
     }
     if (command === 'job') {
@@ -585,6 +595,11 @@ async function main() {
         await runTaskCommand(action ?? '', taskArgs);
         return;
     }
+    if (command === 'review') {
+        const [action, ...reviewArgs] = args;
+        await runReviewCommand(action ?? '', reviewArgs);
+        return;
+    }
     if (command === 'context') {
         const [action, ...contextArgs] = args;
         await runContextCommand(action ?? '', contextArgs);

package/dist/reconciler-review.js

@@ -7,6 +7,7 @@ import { routeExecution } from './execution-routing.js';
 import { ReconcilerRuntimeBase } from './reconciler-runtime.js';
 import { dispatchReviewLifecycle, reviewOutcome } from './workflow/review-v2.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
+import { chatgptThreadRequirements, resolveReviewerThreadDestination } from './reviewer-thread.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) { return await this.store.headSha?.() ?? job.headSha ?? job.review?.headSha ?? null; }
     reviewFacts(job, prState, headSha) {
@@ -108,17 +109,35 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const id = this.nextFinalReviewTaskId(job, headSha);
         const now = new Date().toISOString();
         const reviewGateTasks = implementationTasks(job);
-        const reviewerRouting = await this.selectReviewer(reviewGateTasks);
+        const reviewThread = resolveReviewerThreadDestination(job, this.options.reviewer?.threadId);
+        const reviewerRouting = await this.selectReviewer(reviewGateTasks, reviewThread ? chatgptThreadRequirements(this.options.reviewer?.requirements) : undefined);
+        const chatgptThreadDelivery = reviewThread ? {
+            kind: 'new-turn',
+            threadId: reviewThread.threadId,
+            threadSource: reviewThread.source,
+            requestId: `${job.id}:${id}:${headSha}`,
+            jobId: job.id,
+            prNumber: job.prNumber,
+            reviewHeadSha: headSha,
+            projectId: reviewerRouting.candidate.routing.projectId ?? null,
+        } : undefined;
+        const input = [
+            `Job ID: ${job.id}`,
+            `Review PR #${job.prNumber} at exactly head SHA ${headSha}.`,
+            `Review head SHA: ${headSha}`,
+            'Job objective: ' + (job.objective ?? job.description ?? job.title),
+            'Use the selected reviewer agent contract as the authoritative review protocol.',
+            'This is a PRE-MERGE artifact approval gate: inspect exact PR head, requirements, tests and genuine blocking defects.',
+            'Do not block approval because automatic merge, Job COMPLETED, or post-merge E2E evidence has not occurred yet.',
+            'Do not treat historical failed attempts as current artifact defects; distinguish preserved baseline files from implementation.',
+        ].join('\n\n');
         const task = createTaskEntity(job, {
             jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer',
             parentTaskId: null, dependencies: reviewGateTasks.map(item => item.id), capabilities: ['review'],
             workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter,
-            input: 'Review existing PR #' + job.prNumber + ' at exactly head SHA ' + headSha + '. Job objective: ' + (job.objective ?? job.description ?? job.title) + '. Use the selected reviewer agent contract as the authoritative review protocol. ' +
-                'This is a PRE-MERGE artifact approval gate: inspect the exact PR head, requested changes, applicable source/test requirements, and genuine blocking defects in the proposed changes. ' +
-                'Do not block approval because automatic merge, Job COMPLETED, or post-merge E2E evidence has not occurred yet; those are downstream effects of review approval and independently verified later. ' +
-                'Do not treat historical failed attempts or launch anomalies as current artifact defects if the latest implementation and tests succeeded; report historical lifecycle observations separately. ' +
-                'Compare implementation changes with the PR head that existed before the implementation, not only against main: preserved seed or baseline files are not automatically unrelated additions.',
+            input,
             output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null,
+            chatgptThreadDelivery,
             reviewHeadSha: headSha, attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2,
             leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null,
             error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now
@@ -149,7 +168,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const ready = schedule(await this.store.load(job.id));
         await this.store.saveJob(ready);
     }
-    async selectReviewer(implementationTasks) {
+    async selectReviewer(implementationTasks, requirementsOverride) {
         const configured = this.options.reviewer;
         const registered = await this.store.listAgents();
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
@@ -185,7 +204,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             },
         };
         const runtimeSummary = this.options.runtimeSummaryProvider?.();
-        const routed = await routeExecution(workers, configured?.requirements ?? { capabilities: ['model'] }, {
+        const routed = await routeExecution(workers, requirementsOverride ?? configured?.requirements ?? { capabilities: ['model'] }, {
             decisionEngine: this.options.decisionEngine,
             decisionMode: this.options.decisionMode,
             taskFacts,

package/dist/reconciler.js

@@ -9,6 +9,7 @@ import { createPlanRound, materializePlannerChild, pendingPlan } from './planner
 import { dispatchPlannerOrchestration, plannerOrchestrationFacts } from './workflow/planner-orchestration-v2.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { ReconcilerReviewBase } from './reconciler-review.js';
+import { recordThreadDelivery } from './reviewer-thread.js';
 import { executeManualPlan } from './manual-plan.js';
 import { executionEventSource, withExecutionBoundary } from './reconciler-runtime.js';
 export { executionEventSource } from './reconciler-runtime.js';
@@ -405,9 +406,7 @@ export class Reconciler extends ReconcilerReviewBase {
         const workerTask = { ...task, input: workerInput, routing: task.routing ? { ...task.routing, cwd: executionContext.project.path } : task.routing };
         const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, sourceId, 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'
-            ? this.terminalWait(task.id, durableExecutionId, startedAt - 1)
-            : null;
+        const terminalWait = task.adapter === 'chatgpt' && closePolicy === 'after-terminal' ? this.terminalWait(task.id, durableExecutionId, startedAt - 1) : null;
         const launchContext = {
             ...(startAckSetup ? { waitForWorkerStart: startAckSetup.ack } : {}),
             ...(terminalWait ? { waitForTerminal: terminalWait.promise } : {}),
@@ -422,7 +421,7 @@ export class Reconciler extends ReconcilerReviewBase {
             await this.failLaunch(job.id, task.id, task.executionId, error instanceof Error ? error.message : String(error));
             return;
         }
-        void (execution.launched ?? Promise.resolve()).then(() => this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.process.launched', 'running', `Task ${task.id} process launched`, 'user', { adapter: adapter.id, model: task.routing?.model, pid: execution.pid ?? null, executionId: durableExecutionId }, { agent: 'relay', component: 'agents-relay' }))).catch(error => this.failLaunch(job.id, task.id, durableExecutionId, error instanceof Error ? error.message : String(error), 'launch'));
+        void (execution.launched ?? Promise.resolve()).then(() => Promise.all([recordThreadDelivery(this.store, job.id, task.id, durableExecutionId, workerTask), this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.process.launched', 'running', `Task ${task.id} process launched`, 'user', { adapter: adapter.id, model: task.routing?.model, pid: execution.pid ?? null, executionId: durableExecutionId }, { agent: 'relay', component: 'agents-relay' }))])).catch(error => this.failLaunch(job.id, task.id, durableExecutionId, error instanceof Error ? error.message : String(error), 'launch'));
         if (startAckSetup)
             void startAckSetup.ack.finally(() => { void startAckSetup.stop(); }).catch(() => { });
         this.live.set(task.id, { jobId: job.id, taskId: task.id, executionId: durableExecutionId, execution, controller, launchBarrier: startedAt, workerStarted: false, processSettled: false });

package/dist/relayd.js

@@ -198,7 +198,7 @@ export async function runDaemon(argv) {
             job, githubState: snapshot.facts.state, draft: false, mergedAt: null, closedAt: null, publication: null,
         }));
     }));
-    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), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
+    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), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: executionDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(argv), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
     const refreshAll = async (full = false) => {
         if (client.rateLimitStatus().limited)
             return cachedOverviews;

package/dist/reviewer-thread.js

@@ -0,0 +1,45 @@
+import { arg, hasArg } from './cli-support.js';
+export function normalizeThreadId(value, label = 'thread ID') {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new Error(`${label} must be a string`);
+    const threadId = value.trim();
+    if (!threadId)
+        throw new Error(`${label} cannot be empty`);
+    if (threadId.length > 256)
+        throw new Error(`${label} cannot exceed 256 characters`);
+    return threadId;
+}
+export function resolveReviewerThreadDestination(job, override) {
+    const overridden = override === undefined ? undefined : normalizeThreadId(override, '--thread-id');
+    if (overridden)
+        return { threadId: overridden, source: 'override' };
+    const reviewerThreadId = job.reviewerThreadId ? normalizeThreadId(job.reviewerThreadId, 'Job reviewer thread ID') : undefined;
+    if (reviewerThreadId)
+        return { threadId: reviewerThreadId, source: 'reviewer' };
+    const creatorThreadId = job.creatorThreadId ? normalizeThreadId(job.creatorThreadId, 'Job creator thread ID') : undefined;
+    return creatorThreadId ? { threadId: creatorThreadId, source: 'creator' } : null;
+}
+export function chatgptThreadRequirements(configured) {
+    const base = configured ?? { capabilities: ['model'] };
+    const capabilities = new Set([...base.capabilities, 'model', 'chatgpt', 'browser-workspace']);
+    return { ...base, capabilities: [...capabilities], runtime: 'chatgpt' };
+}
+export function runtimeReviewer(args = []) {
+    const values = [...args];
+    const threadId = arg(values, '--thread-id', '');
+    if (hasArg(values, '--thread-id'))
+        normalizeThreadId(threadId, '--thread-id');
+    return { requirements: { capabilities: ['model'] }, ...(threadId.trim() ? { threadId: threadId.trim() } : {}) };
+}
+export async function recordThreadDelivery(store, jobId, taskId, executionId, workerTask) {
+    const delivery = workerTask.chatgptThreadDelivery;
+    if (!delivery || delivery.deliveredAt)
+        return;
+    const current = (await store.load(jobId)).tasks.find(item => item.id === taskId);
+    if (current?.executionId !== executionId || current.state !== 'RUNNING' || !current.chatgptThreadDelivery)
+        return;
+    current.chatgptThreadDelivery = { ...current.chatgptThreadDelivery, deliveredAt: new Date().toISOString() };
+    await store.saveTask(current);
+}

package/package.json

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