agents-relay 2.0.59 → 2.0.61

package/dist/adapters.js

@@ -93,7 +93,7 @@ export class CodexAdapter {
                 }
             });
         });
-        execution = { id: randomUUID(), promise, launched, cancel: () => { void terminateOwnedProcess(child, 'cancel'); } };
+        execution = { id: randomUUID(), promise, launched, pid: child.pid, cancel: () => { void terminateOwnedProcess(child, 'cancel'); } };
         execution.threadId = bufferedThreadId;
         return execution;
     }

package/dist/cli-shutdown.js

@@ -0,0 +1,16 @@
+/** One-shot CLI commands may have leaked transport handles after durable work ends. */
+export async function runCliEntrypoint(main, options = {}) {
+    let exitCode = 0;
+    try {
+        await main();
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        exitCode = 1;
+    }
+    process.exitCode = exitCode;
+    if (options.serve)
+        return;
+    const timer = setTimeout(() => (options.forceExit ?? process.exit)(exitCode), options.graceMs ?? 2_000);
+    timer.unref();
+}

package/dist/cli-support.js

@@ -145,7 +145,20 @@ export async function withEventBus(args, work, resolve = eventBus) {
         return await work(bus);
     }
     finally {
-        await bus?.close?.();
+        if (bus?.close) {
+            let timer;
+            const deadline = new Promise(resolve => { timer = setTimeout(resolve, 1_500); });
+            try {
+                await Promise.race([bus.close(), deadline]);
+            }
+            catch (error) {
+                process.stderr.write('warning: event bus close failed: ' + (error instanceof Error ? error.message : String(error)) + '\n');
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
     }
 }
 export async function publishWake(bus, job, taskId, message) { if (!bus)

package/dist/cli.js

@@ -14,11 +14,11 @@ import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } fro
 import { eventFor } from './events.js';
 import { serveDashboard } from './dashboard.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
-import { decisionMode, LayaCliDecisionEngine } from './decision.js';
+import { decisionMode, executionDecisionEngine } from './decision.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { transitionJobEvent } from './scheduler.js';
-import { applyOrchestratorStartAction, applyOrchestratorCompleteAction, applyTaskHoldAction, dispatchTaskAction } from './task-actions.js';
+import { applyOrchestratorStartAction, applyOrchestratorCompleteAction, applyTaskHoldAction, applyTaskQueueAction, dispatchTaskAction } from './task-actions.js';
 import { applyJobActivateAction, applyJobCancelAction } from './job-actions.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { defaultWorkspaceRoot, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
@@ -29,6 +29,7 @@ import { helpText, usage } from './cli-help.js';
 import { parseAgentGraph } from './agent-graph.js';
 import { runJobUnblockCommand, runTaskUnblockCommand } from './cli-unblock.js';
 import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js';
+import { runCliEntrypoint } from './cli-shutdown.js';
 import { shutdownOwnedProcesses } from './owned-process.js';
 export { helpText } from './cli-help.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';
@@ -165,7 +166,9 @@ async function runTaskCommand(action, args) {
         await runManagedTaskCommand(action, args);
         return;
     }
-    const { store, job, localFile } = await storeFor(args);
+    const loaded = await storeFor(args);
+    const { store, localFile } = loaded;
+    const job = managed && action === 'update' ? await relayControlJob(args, loaded.job.id) : loaded.job;
     if (action === 'list') {
         console.log(JSON.stringify(job.tasks, null, 2));
         return;
@@ -241,6 +244,7 @@ async function runTaskCommand(action, args) {
         console.log(JSON.stringify(outputTask, null, 2));
         return;
     }
+    const expectedUpdatedAt = task.updatedAt;
     if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
         throw new Error(`Task ${id} is ${task.state}; durable execution fields are immutable in this state`);
     if (hasArg(args, '--adapter')) {
@@ -283,9 +287,13 @@ async function runTaskCommand(action, args) {
     if (hasArg(args, '--draft') && task.state === 'QUEUED')
         await applyTaskHoldAction(task);
     if (hasArg(args, '--queue')) {
-        await store.saveTask(task);
-        const result = await dispatchTaskAction(store, { id: 'task.queue', jobId: job.id, taskId: id });
-        Object.assign(task, result.task);
+        if (managed)
+            await applyTaskQueueAction(job, task);
+        else {
+            await store.saveTask(task);
+            const result = await dispatchTaskAction(store, { id: 'task.queue', jobId: job.id, taskId: id });
+            Object.assign(task, result.task);
+        }
     }
     if (hasArg(args, '--max-attempts') && task.maxAttempts < task.attempt)
         throw new Error('--max-attempts cannot be less than the current attempt count');
@@ -309,6 +317,11 @@ async function runTaskCommand(action, args) {
         if (hasArg(args, '--reasoning') && !hasArg(args, '--timeout'))
             task.timeoutMs = taskOverallTimeoutMs(task.storySize ?? 'M', task.routing.reasoning);
     }
+    if (managed) {
+        const updated = await relayTaskCommand(args, { jobId: job.id, taskId: id, action: 'update', task, expectedUpdatedAt });
+        console.log(JSON.stringify(updated.tasks.find(item => item.id === id), null, 2));
+        return;
+    }
     task.updatedAt = new Date().toISOString();
     await store.saveTask(task);
     await saveLocal(localFile, job);
@@ -458,7 +471,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 { 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: new LayaCliDecisionEngine(), 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(), 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);
@@ -704,4 +717,4 @@ async function main() {
     throw new Error(usage);
 }
 if (isEntrypoint(import.meta.url))
-    main().catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });
+    void runCliEntrypoint(main, { serve: process.argv[2] === 'serve' });

package/dist/dashboard.js

@@ -280,6 +280,8 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
                 let result;
                 if (body.action === 'create' && body.task && resolvedActions?.taskCreate)
                     result = await resolvedActions.taskCreate(requestedJobId, body.task);
+                else if (body.action === 'update' && isTaskId(requestedTaskId) && body.task && body.expectedUpdatedAt && resolvedActions?.taskUpdate)
+                    result = await resolvedActions.taskUpdate(requestedJobId, requestedTaskId, body.task, body.expectedUpdatedAt);
                 else if (body.action === 'start' && isTaskId(requestedTaskId) && resolvedActions?.taskStart)
                     result = await resolvedActions.taskStart(requestedJobId, requestedTaskId);
                 else if (body.action === 'retry' && isTaskId(requestedTaskId) && resolvedActions?.taskRetry)

package/dist/decision.js

@@ -71,6 +71,54 @@ export function parseChoiceDecision(raw, contract) {
         result.probabilities = parsedProbabilities;
     return result;
 }
+/** OpenRouter Decisions API adapter; the choice contract remains engine-independent. */
+export class JevDecisionEngine {
+    options;
+    name = 'openrouter-jev';
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async decide(request, contract) {
+        validateDecisionRequest(request, contract);
+        const apiKey = this.options.apiKey ?? process.env.OPENROUTER_API_KEY;
+        if (!apiKey)
+            throw new Error('OPENROUTER_API_KEY is required for Jev');
+        const choices = Object.fromEntries(contract.choices.map((choice, index) => [`route_${index + 1}`, choice]));
+        const started = Date.now();
+        const response = await (this.options.fetcher ?? fetch)(this.options.endpoint ?? 'https://openrouter.ai/api/alpha/decisions', {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: this.options.model ?? 'typesafe/jev-1.13',
+                state: request.facts,
+                questions: { decision: { type: 'choice', instructions: contract.question, criteria: choices } },
+            }),
+            signal: AbortSignal.timeout(this.options.timeoutMs ?? 12_000),
+        });
+        if (!response.ok)
+            throw new Error(`Jev Decisions API returned HTTP ${response.status}`);
+        const raw = await response.json();
+        const envelope = raw;
+        const answer = envelope?.answers?.decision;
+        if (!answer || typeof answer.choice !== 'string' || !Object.hasOwn(choices, answer.choice)) {
+            throw new Error('Jev returned a choice outside the decision contract');
+        }
+        const mappedProbabilities = answer.probabilities && typeof answer.probabilities === 'object'
+            ? Object.fromEntries(Object.entries(answer.probabilities)
+                .filter(([id]) => Object.hasOwn(choices, id)).map(([id, p]) => [choices[id], p]))
+            : undefined;
+        return {
+            ...parseChoiceDecision({ choice: choices[answer.choice], probabilities: mappedProbabilities }, contract),
+            usage: raw.usage,
+            latencyMs: Date.now() - started,
+            model: raw.model,
+        };
+    }
+}
+/** Select router engine without changing caller-owned hard gates. */
+export function executionDecisionEngine() {
+    return new JevDecisionEngine();
+}
 /**
  * Stateless Laya invocation. The adapter materializes the caller's JSON state
  * and question contract as temporary files for `uvx laya-mlx predict`. It is

package/dist/execution-process-tracker.js

@@ -0,0 +1,35 @@
+import { activeRelayLeaseOwner, captureProcessRecord, probeProcessRecord, stopOrphanedProcessGroup } from './process-identity.js';
+/** Correlate Relay execution IDs with OS process identity in SQLite, never GitHub. */
+export async function monitorExecutionProcess(store, jobId, taskId, executionId, owner, execution) {
+    if (!execution.pid || !store.recordExecutionProcess)
+        return;
+    const registration = (async () => {
+        const record = await captureProcessRecord(jobId, taskId, executionId, owner, execution.pid);
+        if (record)
+            await store.recordExecutionProcess?.(record);
+    })();
+    const closeRecord = async () => {
+        await registration;
+        await store.finishExecutionProcess?.(jobId, taskId, executionId);
+    };
+    void execution.promise.then(closeRecord, closeRecord).catch(() => {
+        // Recording failures are surfaced by the registration promise to the caller.
+    });
+    await registration;
+}
+/** Reuse only if the previous exact process has gone or safely been reaped. */
+export async function reclaimStaleExecutionProcess(store, task, currentOwner) {
+    if (!task.executionId || !task.jobId || !store.loadExecutionProcess)
+        return true;
+    const record = await store.loadExecutionProcess(task.jobId, task.id, task.executionId);
+    if (task.leaseOwner && task.leaseOwner !== currentOwner && await activeRelayLeaseOwner(task.leaseOwner))
+        return false;
+    if (!record || record.endedAt)
+        return true;
+    const state = await probeProcessRecord(record);
+    if (state === 'gone' || state === 'reused')
+        return true;
+    if (state !== 'alive' || (task.leaseOwner && task.leaseOwner !== currentOwner && await activeRelayLeaseOwner(task.leaseOwner)))
+        return false;
+    return await stopOrphanedProcessGroup(record);
+}

package/dist/execution-recovery.js

@@ -1,4 +1,5 @@
 import { transitionTaskEvent } from './scheduler.js';
+import { reclaimStaleExecutionProcess } from './execution-process-tracker.js';
 async function currentGeneration(store, job, stale) {
     const task = (await store.load(job.id)).tasks.find(item => item.id === stale.id);
     if (!task)
@@ -23,14 +24,18 @@ export async function recoverExpiredExecutions(job, now, ports) {
         const recoverable = task && (task.state === 'RUNNING' || (task.state === 'QUEUED' && task.executionId !== null));
         if (!recoverable || task.leaseExpiresAt === null || new Date(task.leaseExpiresAt).getTime() > now)
             continue;
+        if (!await reclaimStaleExecutionProcess(ports.store, task, ports.owner))
+            continue;
         await recoverTask(task, 'lease.expired', 'lease_expired', ports);
     }
 }
 export async function recoverStartupOrphans(job, ports) {
-    const candidates = job.tasks.filter(task => task.kind !== 'planner' && task.state === 'RUNNING' && task.executionId && task.leaseOwner && task.leaseOwner !== ports.owner && task.adapter !== 'chatgpt');
+    const candidates = job.tasks.filter(task => task.kind !== 'planner' && (task.state === 'RUNNING' || task.state === 'QUEUED') && task.executionId && task.leaseOwner && task.leaseOwner !== ports.owner && task.adapter !== 'chatgpt');
     for (const stale of candidates) {
         const task = await currentGeneration(ports.store, job, stale);
-        if (!task || task.state !== 'RUNNING' || task.adapter === 'chatgpt' || !task.executionId || !task.leaseOwner || task.leaseOwner === ports.owner)
+        if (!task || !['RUNNING', 'QUEUED'].includes(task.state) || task.adapter === 'chatgpt' || !task.executionId || !task.leaseOwner || task.leaseOwner === ports.owner)
+            continue;
+        if (!await reclaimStaleExecutionProcess(ports.store, task, ports.owner))
             continue;
         await recoverTask(task, 'execution.orphaned', 'startup_orphaned', ports);
     }

package/dist/execution-routing.js

@@ -17,11 +17,35 @@ export function executionTaskShape(taskFacts = {}) {
             : 'Small/medium tasks favor ChatGPT when Browser Workspace capacity is available.',
     };
 }
+/** Explicit task capability tags override heuristic inference; legacy capabilities are additive. */
+export function taskCapabilityFacts(taskFacts) {
+    const task = taskFacts.task && typeof taskFacts.task === 'object' ? taskFacts.task : taskFacts;
+    const explicit = task.taskCapabilities ?? task.task_capabilities;
+    const legacy = task.capabilities;
+    const tags = [...(Array.isArray(explicit) ? explicit : []), ...(Array.isArray(legacy) ? legacy : [])]
+        .filter((item) => typeof item === 'string' && item.trim().length > 0);
+    if (Array.isArray(explicit) && explicit.length > 0)
+        return [...new Set(tags)];
+    const description = [task.input, task.title, task.description, task.role].filter(item => typeof item === 'string').join(' ').toLowerCase();
+    if (/image generation|generate (an? )?image|生成图片|图片生成|生图/.test(description))
+        tags.push('image_generation');
+    if (/final review|final approval review|最终审核|最终审查|终审/.test(description))
+        tags.push('final_review');
+    if (/visual review|image review|视觉审核|图片审核|画面审核/.test(description))
+        tags.push('visual_review');
+    if (/vision|image understanding|图像理解|图片理解|看图/.test(description))
+        tags.push('vision');
+    return [...new Set(tags)];
+}
+function workerCapabilityFacts(worker) {
+    const specializations = worker.adapter === 'chatgpt' ? ['vision', 'image_generation', 'visual_review', 'final_review'] : ['coding', 'cli', 'filesystem'];
+    return [...new Set([...worker.capabilities, ...specializations])];
+}
 export const EXECUTION_ROUTING_PRINCIPLES = [
     'Choose one complete executable route: worker plus provider/model/profile/reasoning.',
     'ChatGPT with MacBridge and Codex have broadly overlapping execution capabilities.',
     "Browser Workspace exhaustion is ChatGPT's primary hard execution constraint.",
-    'Codex is only the deterministic fallback when the decision engine fails.',
+    'Codex is the deterministic fallback when Jev fails; no second decision model is invoked.',
 ];
 function sameModelRoute(candidate, route) {
     return (!route.provider || candidate.provider === route.provider)
@@ -110,7 +134,7 @@ async function decideStage(engine, name, facts, question, choices) {
     const decision = await engine.decide({ facts }, contract);
     if (decision.type !== 'choice')
         throw new Error('Execution router expected a choice result for ' + name);
-    return { name, facts, contract, result: { choice: decision.choice, probabilities: decision.probabilities } };
+    return { name, facts, contract, result: { choice: decision.choice, probabilities: decision.probabilities, usage: decision.usage, latencyMs: decision.latencyMs, model: decision.model } };
 }
 function routeId(worker, model) {
     return worker.workerId + '::' + model.id + (model.reasoning ? '@' + model.reasoning : '');
@@ -265,10 +289,13 @@ export async function routeExecution(workers, requirements, options = {}) {
         source: isDefaultCandidate(route.model, discoveredDefaults.get(route.worker.workerId) ?? []) ? 'profile-default' : 'explicit-choice',
     }));
     const choiceLabels = routes.map((route, index) => executionChoiceLabel(route, effectiveChoices[index].default));
+    // Usage is keyed by worker/provider, not repeated for every route choice.
+    const usageByProvider = Object.fromEntries([...new Map(routes.map(route => [
+            route.worker.workerId + '::' + route.model.provider,
+            { worker: route.worker.workerId, provider: route.model.provider, ...codePlan(route.model) },
+        ])).entries()]);
     const facts = JSON.parse(JSON.stringify({
         context: {
-            job: taskFacts.job ?? null,
-            task: taskFacts.task ?? taskFacts,
             task_shape: {
                 story_size: taskShape.storySize,
                 sustained_work: taskShape.sustainedWork,
@@ -280,14 +307,19 @@ export async function routeExecution(workers, requirements, options = {}) {
                 reviewer_diversity: taskFacts.reviewer_diversity,
             } : null,
         },
+        task_capabilities: taskCapabilityFacts(taskFacts),
+        task_worker_capabilities: (() => {
+            const task = taskFacts.task && typeof taskFacts.task === 'object' ? taskFacts.task : taskFacts;
+            return Array.isArray(task.workerCapabilities) ? task.workerCapabilities : [];
+        })(),
+        worker_capabilities: Object.fromEntries(workers.map(worker => [worker.workerId, workerCapabilityFacts(worker)])),
+        usage_by_provider: usageByProvider,
         runtime: {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
         },
-        worker_candidates: workerProviderFacts(routes),
-        effective_choices: effectiveChoices,
     }));
-    const question = appendRoutingInstruction('Choose one complete route from the merged choice list. Relay has already merged profile defaults with the user\'s explicit [choices] and applied every authoritative hard gate, so only these routes are legal. Do not invent, add, or substitute routes that are not listed.', routingInstruction);
+    const question = appendRoutingInstruction('User routing instructions have highest priority over default preferences, task size, runtime and resource signals. Candidate order is arbitrary and conveys no priority, ranking or preference. Do not favor earlier choices. Select an offered route that obeys the user instructions.\nUser routing instructions:\n' + routingInstruction, 'For vision, image generation, visual review, and final review tasks, prefer ChatGPT Worker when available and within capacity; for coding, CLI and filesystem tasks, prefer Codex. These are soft preferences subordinate to user rules. Choose exactly one listed route; do not invent routes.');
     let selected = fallback;
     let evidence = { mode: options.decisionMode ?? 'off', fallback: true };
     const decisionStages = [];
@@ -297,7 +329,7 @@ export async function routeExecution(workers, requirements, options = {}) {
             decisionStages.push(stage);
             const index = stage.result.choice ? choiceLabels.indexOf(stage.result.choice) : -1;
             if (index < 0)
-                throw new Error('Laya selected a route outside the merged choice list');
+                throw new Error('Decision engine selected a route outside the merged choice list');
             selected = routes[index];
             evidence = {
                 mode: options.decisionMode ?? 'active',

package/dist/model-redecision.js

@@ -31,7 +31,7 @@ export async function redecideFailedTask(options) {
         rulesPath: options.rulesPath,
         auditStore: options.auditStore,
         auditTask: options.task,
-        taskFacts: { kind: options.task.kind ?? 'work', capabilities: options.task.capabilities, prior_routing: options.task.routing ?? null, fresh_usage_generated_at: usage.generatedAt },
+        taskFacts: { kind: options.task.kind ?? 'work', capabilities: options.task.capabilities, taskCapabilities: options.task.taskCapabilities, workerCapabilities: options.task.workerCapabilities, input: options.task.input, prior_routing: options.task.routing ?? null, fresh_usage_generated_at: usage.generatedAt },
         priorDecisionId: options.task.routing?.decisionId,
         priorFailure: options.evidence,
         excludedRoutes: options.task.routing ? [{ provider: options.task.routing.provider, model: options.task.routing.model, profile: options.task.routing.profile }] : [],

package/dist/owned-process.js

@@ -28,15 +28,15 @@ function signalOwned(record, signal) {
     try {
         if (record.processGroup !== null)
             process.kill(-record.processGroup, signal);
-        else
-            record.child.kill(signal);
-        return true;
+        else if (!record.child.kill(signal))
+            return 'gone';
+        return 'sent';
     }
     catch (error) {
         if (error.code === 'ESRCH')
-            return false;
+            return 'gone';
         audit(record, 'process.signal_failed', 'failed', { signal, error: error instanceof Error ? error.message : String(error) });
-        return false;
+        return 'error';
     }
 }
 function forceOwned(record, reason) {
@@ -47,8 +47,8 @@ function forceOwned(record, reason) {
         audit(record, 'process.signal', result.status === 0 ? 'succeeded' : 'failed', { reason, signal: 'taskkill-/t-/f', exitStatus: result.status });
         return;
     }
-    const sent = signalOwned(record, 'SIGKILL');
-    audit(record, 'process.signal', sent ? 'succeeded' : 'failed', { reason, signal: 'SIGKILL' });
+    const outcome = signalOwned(record, 'SIGKILL');
+    audit(record, 'process.signal', outcome === 'error' ? 'failed' : 'succeeded', { reason, signal: 'SIGKILL', delivered: outcome === 'sent', alreadyGone: outcome === 'gone' });
 }
 function installExitHook() {
     if (exitHookInstalled)
@@ -143,8 +143,8 @@ export async function terminateOwnedProcess(child, reason, graceMs) {
         return;
     if (!record.terminating) {
         record.terminating = true;
-        const sent = signalOwned(record, 'SIGTERM');
-        audit(record, 'process.signal', sent ? 'succeeded' : 'failed', { reason, signal: 'SIGTERM' });
+        const outcome = signalOwned(record, 'SIGTERM');
+        audit(record, 'process.signal', outcome === 'error' ? 'failed' : 'succeeded', { reason, signal: 'SIGTERM', delivered: outcome === 'sent', alreadyGone: outcome === 'gone' });
         record.forceTimer = setTimeout(() => forceOwned(record, reason), graceMs ?? record.graceMs);
         record.forceTimer.unref();
     }

package/dist/planner-runtime.js

@@ -58,7 +58,6 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
         plan.plannerResult = result;
         plan.assessment = result.assessment;
         plan.generatedTaskIds = result.next_tasks.map(item => item.id);
-        plan.headSha = plan.trigger.currentHeadSha ?? await ports.store.headSha?.() ?? job.headSha;
         plan.error = undefined;
         plan.retryFeedback = undefined;
         plan.leaseOwner = null;
@@ -101,6 +100,9 @@ export async function launchPlanExecution(ports, job, plan) {
         const live = ports.live.get(fresh.id);
         if (fresh.executionId && fresh.leaseOwner === ports.options.owner && live?.executionId === fresh.executionId)
             return null;
+        fresh.headSha = await ports.store.headSha?.() ?? fresh.headSha;
+        if (fresh.headSha)
+            fresh.trigger = { ...fresh.trigger, currentHeadSha: fresh.headSha };
         const startedAt = (ports.options.now ?? new Date()).getTime();
         fresh.attempt = (fresh.attempt ?? 0) + 1;
         fresh.maxAttempts ??= fresh.manualPlanning ? 1 : 3;

package/dist/planner.js

@@ -99,7 +99,9 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
     const decisionId = 'round' in planner ? planner.id : planner.id;
     const source = 'round' in planner ? planner.source : planner.planningSource ?? 'model-planner';
     const round = 'round' in planner ? planner.round : planner.planningRound ?? 1;
-    return createTaskEntity(job, { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, adapter: 'codex', input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: decisionId, planningSource: source, planningRound: round });
+    const plannerHeadSha = 'round' in planner ? planner.headSha : undefined;
+    const reviewHeadSha = spec.agentName === 'reviewer' ? plannerHeadSha ?? job.headSha : undefined;
+    return createTaskEntity(job, { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, adapter: 'codex', input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: decisionId, planningSource: source, planningRound: round, reviewHeadSha });
 }
 export function planningSpec(task) {
     if (!task.output && task.adapter !== 'orchestrator')

package/dist/process-identity.js

@@ -0,0 +1,83 @@
+import { execFile } from 'node:child_process';
+import { hostname } from 'node:os';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** ps lstart and PGID together guard against PID reuse after daemon restart. */
+export async function observeProcess(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 2)
+        return null;
+    try {
+        const { stdout } = await execFileAsync('ps', ['-p', String(pid), '-o', 'pgid=', '-o', 'lstart='], { timeout: 1500, maxBuffer: 2048 });
+        const match = stdout.trim().match(/^(\d+)\s+(.+)$/);
+        return match && Number(match[1]) > 0 ? { pgid: Number(match[1]), startToken: match[2].trim() } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function captureProcessRecord(jobId, taskId, executionId, leaseOwner, pid) {
+    const snapshot = await observeProcess(pid);
+    return snapshot && snapshot.pgid === pid ? {
+        jobId, taskId, executionId, leaseOwner, host: hostname(), pid,
+        pgid: snapshot.pgid, startToken: snapshot.startToken, observedAt: new Date().toISOString(),
+    } : null;
+}
+export async function probeProcessRecord(record) {
+    if (record.host !== hostname() || !record.startToken || record.pid !== record.pgid)
+        return 'unknown';
+    const current = await observeProcess(record.pid);
+    if (current)
+        return current.pgid === record.pgid && current.startToken === record.startToken ? 'alive' : 'reused';
+    try {
+        process.kill(record.pid, 0);
+        return 'unknown';
+    }
+    catch (error) {
+        return error.code === 'ESRCH' ? 'gone' : 'unknown';
+    }
+}
+/** A separate still-running relay daemon must retain its live lease. */
+export async function activeRelayLeaseOwner(owner) {
+    const match = owner.match(/^relayd-(\d+)$/);
+    if (!match || Number(match[1]) <= 1)
+        return false;
+    try {
+        const { stdout } = await execFileAsync('ps', ['-p', match[1], '-o', 'command='], { timeout: 1500, maxBuffer: 4096 });
+        return /\bagents-relayd\b/.test(stdout) || /(?:^|\/)relayd(?:-main)?\.js(?:\s|$)/.test(stdout);
+    }
+    catch {
+        return false;
+    }
+}
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** Never signal another PID generation, remote host, or non-leader process group. */
+export async function stopOrphanedProcessGroup(record, graceMs = 750) {
+    let state = await probeProcessRecord(record);
+    if (state === 'gone' || state === 'reused')
+        return true;
+    if (state !== 'alive' || process.platform === 'win32')
+        return false;
+    try {
+        process.kill(-record.pgid, 'SIGTERM');
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH')
+            return false;
+    }
+    await sleep(graceMs);
+    state = await probeProcessRecord(record);
+    if (state === 'gone' || state === 'reused')
+        return true;
+    if (state !== 'alive')
+        return false;
+    try {
+        process.kill(-record.pgid, 'SIGKILL');
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH')
+            return false;
+    }
+    await sleep(100);
+    state = await probeProcessRecord(record);
+    return state === 'gone' || state === 'reused';
+}

package/dist/projected-store.js

@@ -192,6 +192,14 @@ export class ProjectedDurableStore {
         if (this.seededFacts)
             void this.relay.savePullRequestFacts(this.seededFacts).catch(() => { });
     }
+    // Process identities are operational SQLite records: never enqueue GitHub projection.
+    async recordExecutionProcess(record) { await this.relay.recordExecutionProcess(record); }
+    async loadExecutionProcess(jobId, taskId, executionId) {
+        return this.relay.loadExecutionProcess(jobId, taskId, executionId);
+    }
+    async finishExecutionProcess(jobId, taskId, executionId) {
+        await this.relay.finishExecutionProcess(jobId, taskId, executionId);
+    }
     /** Ingest trusted GitHub records without echoing them back through the projection outbox. */
     async hydrate(job) {
         await this.relay.ingestJobSnapshot(structuredClone(job));

package/dist/reconciler-review.js

@@ -25,6 +25,44 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             noApprovedCurrentReview: !reviewTasks.some(task => task.state === 'SUCCEEDED' && job.review?.headSha === headSha && job.review.outcome === 'approved'),
         };
     }
+    static reviewRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    }
+    static reviewHeadSha(event) {
+        const data = ReconcilerReviewBase.reviewRecord(event.data);
+        const outcome = ReconcilerReviewBase.reviewRecord(data.outcome);
+        const review = ReconcilerReviewBase.reviewRecord(data.review);
+        return [outcome.head_sha, outcome.headSha, review.head_sha, review.headSha, data.head_sha, data.headSha]
+            .find((value) => typeof value === 'string' && value.length > 0);
+    }
+    static reviewIssues(event) {
+        const data = ReconcilerReviewBase.reviewRecord(event.data);
+        const outcome = ReconcilerReviewBase.reviewRecord(data.outcome);
+        const review = ReconcilerReviewBase.reviewRecord(data.review);
+        const rawIssues = outcome.blocking_findings !== undefined ? outcome.blocking_findings
+            : outcome.blockingFindings !== undefined ? outcome.blockingFindings
+                : review.issues !== undefined ? review.issues
+                    : data.issues;
+        if (!Array.isArray(rawIssues))
+            return [];
+        return rawIssues.map(item => {
+            if (typeof item === 'string')
+                return item.trim();
+            if (!item || typeof item !== 'object' || Array.isArray(item))
+                return '';
+            const value = item;
+            return (typeof value.summary === 'string' ? value.summary
+                : typeof value.message === 'string' ? value.message
+                    : typeof value.finding === 'string' ? value.finding
+                        : typeof value.title === 'string' ? value.title : '').trim();
+        }).filter(Boolean);
+    }
+    static normalizeReviewEvidence(event, task) {
+        const headSha = ReconcilerReviewBase.reviewHeadSha(event);
+        if (!headSha)
+            return null;
+        return { headSha, issues: ReconcilerReviewBase.reviewIssues(event) };
+    }
     async cancelStaleReviewTask(job) {
         const staleTask = job.review?.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
         if (!staleTask || !['DRAFT', 'QUEUED', 'RUNNING'].includes(staleTask.state))
@@ -179,7 +217,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 id: task.id, kind: task.kind ?? 'work', storySize: task.storySize ?? 'M',
                 priority: task.priority ?? null, agentName: task.agentName ?? null,
                 parentTaskId: task.parentTaskId, dependencies: task.dependencies,
-                capabilities: task.capabilities, input: task.input,
+                capabilities: task.capabilities, taskCapabilities: task.taskCapabilities, workerCapabilities: task.workerCapabilities, input: task.input,
                 attachments: task.attachments ?? [], output: task.output ?? null,
                 state: task.state, attempt: task.attempt, maxAttempts: task.maxAttempts,
             },
@@ -218,10 +256,14 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async applyReviewEvent(event) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id && item.agentName === 'reviewer');
-        const reviewData = event.data?.review && typeof event.data.review === 'object' ? event.data.review : undefined;
-        const headSha = typeof reviewData?.headSha === 'string' ? reviewData.headSha : typeof event.data?.headSha === 'string' ? event.data.headSha : task?.reviewHeadSha;
-        if (!task || !headSha || task.reviewHeadSha !== headSha)
+        if (!task)
+            return { applied: false, reconcile: false, reason: event.type + '.ignored' };
+        const normalizedEvidence = ReconcilerReviewBase.normalizeReviewEvidence(event, task);
+        if (!normalizedEvidence)
             return { applied: false, reconcile: false, reason: event.type + '.ignored' };
+        const headSha = normalizedEvidence.headSha;
+        if (task.reviewHeadSha !== headSha)
+            return { applied: false, reconcile: false, reason: event.type + '.stale' };
         const currentHeadSha = await this.store.headSha?.();
         if ((currentHeadSha && currentHeadSha !== headSha) || (job.headSha && job.headSha !== headSha))
             return { applied: false, reconcile: false, reason: event.type + '.stale' };
@@ -239,16 +281,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const reviewDecision = await dispatchReviewLifecycle(job.review?.outcome, event.type, { autoMerge: job.autoMerge !== false }, async (actionId) => {
             if (actionId === 'review.createFix') {
                 needsReconcile = true;
-                const rawIssues = Array.isArray(reviewData?.issues) ? reviewData.issues : [];
-                const issues = rawIssues.map(item => {
-                    if (typeof item === 'string')
-                        return item.trim();
-                    if (item && typeof item === 'object') {
-                        const value = item;
-                        return (typeof value.summary === 'string' ? value.summary : typeof value.message === 'string' ? value.message : typeof value.title === 'string' ? value.title : '').trim();
-                    }
-                    return '';
-                }).filter(Boolean);
+                const issues = normalizedEvidence.issues;
                 if (issues.length === 0)
                     issues.push(event.message || 'Address the reviewer-requested changes');
                 const now = event.timestamp || new Date().toISOString();
@@ -275,7 +308,11 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const outcome = reviewOutcome(reviewDecision.target);
         if (!outcome)
             return { applied: false, reconcile: false, reason: event.type + '.ignored' };
-        const evidence = { summary: event.message || 'Review ' + outcome, data: { ...(event.data ?? {}), review: reviewData ?? { headSha }, headSha, outcome } };
+        const reviewData = event.data?.review && typeof event.data.review === 'object' && !Array.isArray(event.data.review)
+            ? event.data.review : undefined;
+        const evidence = { summary: event.message || 'Review ' + outcome, data: {
+                ...(event.data ?? {}), review: { ...(reviewData ?? {}), headSha }, headSha, outcome, source: event.source,
+            } };
         job.review = { outcome, headSha, taskId: task.id, evidence, updatedAt: event.timestamp || new Date().toISOString() };
         job.updatedAt = job.review.updatedAt;
         await this.store.saveJob(job);

package/dist/reconciler-runtime.js

@@ -6,6 +6,8 @@ import { WorkflowEffectExecutor } from './workflow/effects.js';
 import { workflowEffectFailureEvent } from './workflow/contracts.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { acceptedReportedTag, eventDataWithoutTag } from './task-tag.js';
+import { rearmTerminalEventDeadline } from './terminal-event-watchdog.js';
+import { monitorExecutionProcess } from './execution-process-tracker.js';
 export function executionEventSource(jobId, taskId, executionId) { return `job/${jobId}/task/${taskId}/execution/${executionId}`; }
 function eventSourceId(event) { return typeof event.source?.id === 'string' ? event.source.id : undefined; }
 function executionIdFromSource(sourceId, jobId, taskId) {
@@ -224,6 +226,9 @@ export class ReconcilerRuntimeBase {
     }
     registerExecutionOwner(jobId, taskId, executionId) {
         activeExecutionOwners.set(executionEventSource(jobId, taskId, executionId), this);
+        const live = this.live.get(taskId);
+        if (live)
+            this.detach(monitorExecutionProcess(this.store, jobId, taskId, executionId, this.options.owner, live.execution), jobId, taskId, 'execution PID correlation');
     }
     cancelExecutionGeneration(jobId, taskId, executionId) {
         if (!executionId)
@@ -336,10 +341,10 @@ export class ReconcilerRuntimeBase {
         const task = job.tasks.find(item => item.id === taskId);
         if (!task || (task.executionId !== executionId && !terminalExecutionClaimed(jobId, taskId, executionId)))
             return;
-        if (task.adapter !== 'chatgpt')
-            this.clearTerminalTimer(taskId, executionId);
+        if (task.adapter !== 'chatgpt' && task.executionId === executionId && live?.executionId === executionId)
+            rearmTerminalEventDeadline(this.terminalTimers, taskId, task.timeoutMs - (Date.now() - live.launchBarrier), this.options.postExitTerminalGraceMs ?? 15_000, () => this.detach(this.timeoutTask(jobId, taskId, executionId), jobId, taskId, 'post-exit terminal event timeout'));
         await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (error ? 'Worker runtime exited with error' : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
-            signal: live?.execution.processExit?.signal ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error }, { agent: 'relay', component: 'agents-relay' }));
+            signal: live?.execution.processExit?.signal ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error, executionId, pid: live?.execution.pid ?? null }, { id: executionEventSource(jobId, taskId, executionId), agent: 'relay', component: 'agents-relay' }));
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);

package/dist/reconciler.js

@@ -470,7 +470,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 }, { 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(() => 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/relay-store.js

@@ -74,6 +74,19 @@ export class SQLiteRelayStore {
         sequence INTEGER,
         received_at TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS execution_process (
+        job_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        execution_id TEXT NOT NULL,
+        lease_owner TEXT NOT NULL,
+        host TEXT NOT NULL,
+        pid INTEGER NOT NULL,
+        pgid INTEGER NOT NULL,
+        start_token TEXT NOT NULL,
+        observed_at TEXT NOT NULL,
+        ended_at TEXT,
+        PRIMARY KEY(job_id,task_id,execution_id)
+      );
       ${ProjectionOutbox.createTableSql()}
       ${ProjectionOutbox.createIndexSql()}
     `);
@@ -201,6 +214,26 @@ export class SQLiteRelayStore {
       ON CONFLICT(id) DO UPDATE SET state=excluded.state,head_ref=excluded.head_ref,head_sha=excluded.head_sha,observed_at=excluded.observed_at
     `).run(facts.state, facts.head?.ref ?? null, facts.head?.sha ?? null, facts.observedAt);
     }
+    async recordExecutionProcess(record) {
+        const existing = await this.loadExecutionProcess(record.jobId, record.taskId, record.executionId);
+        if (existing && (existing.pid !== record.pid || existing.pgid !== record.pgid || existing.host !== record.host || existing.startToken !== record.startToken)) {
+            throw new Error(`Conflicting process identity for ${record.jobId}/${record.taskId}/${record.executionId}`);
+        }
+        this.db.prepare(`INSERT OR IGNORE INTO execution_process
+      (job_id,task_id,execution_id,lease_owner,host,pid,pgid,start_token,observed_at,ended_at)
+      VALUES(?,?,?,?,?,?,?,?,?,?)`).run(record.jobId, record.taskId, record.executionId, record.leaseOwner, record.host, record.pid, record.pgid, record.startToken, record.observedAt, record.endedAt ?? null);
+    }
+    async loadExecutionProcess(jobId, taskId, executionId) {
+        const row = this.db.prepare(`SELECT lease_owner,host,pid,pgid,start_token,observed_at,ended_at
+      FROM execution_process WHERE job_id=? AND task_id=? AND execution_id=?`).get(jobId, taskId, executionId);
+        return row ? { jobId, taskId, executionId, leaseOwner: row.lease_owner,
+            host: row.host, pid: row.pid, pgid: row.pgid, startToken: row.start_token,
+            observedAt: row.observed_at, endedAt: row.ended_at } : null;
+    }
+    async finishExecutionProcess(jobId, taskId, executionId, at = new Date().toISOString()) {
+        this.db.prepare('UPDATE execution_process SET ended_at=COALESCE(ended_at,?) WHERE job_id=? AND task_id=? AND execution_id=?')
+            .run(at, jobId, taskId, executionId);
+    }
     async markEventProcessed(eventId, stream = null, sequence = null) {
         const result = this.db.prepare(`
       INSERT OR IGNORE INTO event_receipt(event_id,stream,sequence,received_at) VALUES(?,?,?,?)

package/dist/relayd.js

@@ -17,11 +17,12 @@ import { eventBusResolutionMessage, publishOrchestratorTaskStarted, publishOrche
 import { eventFor } from './events.js';
 import { applyJobActivateAction } from './job-actions.js';
 import { applyOrchestratorStartAction, applyOrchestratorCompleteAction } from './task-actions.js';
+import { managedTaskUpdateHandler } from './task-update.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
-import { decisionMode, LayaCliDecisionEngine } from './decision.js';
+import { decisionMode, executionDecisionEngine } from './decision.js';
 import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
 import { executionRouterRulesPath } from './routing-policy.js';
@@ -197,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: new LayaCliDecisionEngine(), 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(), 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;
@@ -404,6 +405,8 @@ export async function runDaemon(argv) {
         cancel: workspaceJobAction('cancel'),
         jobSetState: workspaceJobSetState,
         taskCreate: workspaceTaskCreate,
+        taskUpdate: managedTaskUpdateHandler(jobId => { const row = cachedOverviews.find(item => item.job.id === jobId); if (!row)
+            throw new Error('Job not found'); return { store: runtimeStore(row.job.repository, row.job.prNumber), repository: row.job.repository, prNumber: row.job.prNumber }; }, (repository, prNumber, jobId) => pool.reconcileTarget(repository, prNumber, jobId, 'control.task.update')),
         taskStart: workspaceTaskStart,
         taskRetry: workspaceTaskAction('retry'),
         taskCancel: workspaceTaskAction('cancel'),
@@ -424,7 +427,7 @@ export async function runDaemon(argv) {
             { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-workspace'] },
         ], [], usage);
         const result = await routeExecution(workers, task.workerRequirements ?? { capabilities: task.capabilities ?? [] }, {
-            decisionEngine: new LayaCliDecisionEngine(),
+            decisionEngine: executionDecisionEngine(),
             decisionMode: 'active',
             taskFacts: {
                 job: {
@@ -437,7 +440,7 @@ export async function runDaemon(argv) {
                     id: task.id, kind: task.kind ?? 'work', storySize: task.storySize ?? 'M',
                     priority: task.priority ?? null, agentName: task.agentName ?? null,
                     parentTaskId: task.parentTaskId, dependencies: task.dependencies,
-                    capabilities: task.capabilities, input: task.input,
+                    capabilities: task.capabilities, taskCapabilities: task.taskCapabilities, workerCapabilities: task.workerCapabilities, input: task.input,
                     attachments: task.attachments ?? [], output: task.output ?? null,
                     state: task.state, attempt: task.attempt, maxAttempts: task.maxAttempts,
                 },

package/dist/task-update.js

@@ -0,0 +1,52 @@
+import { applyTaskHoldAction, applyTaskQueueAction } from './task-actions.js';
+const editableFields = [
+    'priority', 'storySize', 'projectName', 'agentName', 'agentGraph',
+    'parentTaskId', 'dependencies', 'capabilities', 'workerRequirements',
+    'adapter', 'chatgptTabClosePolicy', 'input', 'attachments',
+    'routing', 'timeoutMs', 'maxAttempts',
+];
+/** All managed CLI Task updates commit through the daemon's operational store. */
+export async function applyManagedTaskUpdate(store, jobId, taskId, proposed, expectedUpdatedAt) {
+    const job = await store.load(jobId);
+    const current = job.tasks.find(item => item.id === taskId);
+    if (!current || proposed.id !== taskId || proposed.jobId !== jobId)
+        throw new Error('Task update identity mismatch');
+    if (current.updatedAt !== expectedUpdatedAt)
+        throw new Error('Task changed since update preflight; refresh and retry');
+    if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(current.state) || current.executionId || current.leaseOwner)
+        throw new Error('Task is not mutable while active or terminal');
+    if (current.attempt > 0 && current.adapter !== proposed.adapter)
+        throw new Error('Cannot replace adapter after an execution attempt');
+    if (proposed.maxAttempts < current.attempt)
+        throw new Error('Retry budget is below execution attempts');
+    const next = structuredClone(current);
+    for (const key of editableFields) {
+        if (Object.hasOwn(proposed, key))
+            next[key] = structuredClone(proposed[key]);
+        else
+            delete next[key];
+    }
+    if (next.dependencies.includes(taskId))
+        throw new Error('Task cannot depend on itself');
+    if (proposed.state !== current.state) {
+        if (proposed.state === 'DRAFT' && current.state === 'QUEUED')
+            await applyTaskHoldAction(next);
+        else if (proposed.state === 'QUEUED')
+            await applyTaskQueueAction(job, next);
+        else
+            throw new Error('Task state change requires a dedicated lifecycle action');
+    }
+    if (next.adapter !== current.adapter || JSON.stringify(next.routing) !== JSON.stringify(current.routing))
+        next.workerSelection = undefined;
+    next.updatedAt = new Date().toISOString();
+    await store.saveTask(next);
+    return store.load(jobId);
+}
+export function managedTaskUpdateHandler(locate, wake) {
+    return async (jobId, taskId, task, expectedUpdatedAt) => {
+        const target = locate(jobId);
+        const updated = await applyManagedTaskUpdate(target.store, jobId, taskId, task, expectedUpdatedAt);
+        await wake(target.repository, target.prNumber, jobId);
+        return updated;
+    };
+}

package/dist/terminal-event-watchdog.js

@@ -0,0 +1,11 @@
+/**
+ * Replace the overall worker deadline with a shorter post-exit deadline.
+ * Execution outcomes remain owned by the authoritative task lifecycle graph.
+ * Never extend the original overall timeout.
+ */
+export function rearmTerminalEventDeadline(timers, taskId, overallRemainingMs, graceMs, expire) {
+    const existing = timers.get(taskId);
+    if (existing)
+        clearTimeout(existing);
+    timers.set(taskId, setTimeout(expire, Math.max(1, Math.min(overallRemainingMs, graceMs))));
+}

package/package.json

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

package/workflow/task-lifecycle.mmd

@@ -120,6 +120,7 @@ queued -->|on: worker.delivery_failed| failed
 queued -->|on: worker.start_ack_failed| failed
 queued -->|on: planner.unavailable| plannerUnavailableMark
 plannerUnavailableMark --> failed
+queued -->|on: execution.orphaned| orphanRetryAvailable
 queued -->|on: lease.expired| retryAvailableQueued
 retryAvailableQueued -->|true| leaseRetryQueuedClearError
 leaseRetryQueuedClearError --> leaseRetryQueuedClearLease