agents-relay 2.0.58 → 2.0.60

package/dist/owned-process.js

@@ -0,0 +1,170 @@
+import { spawn, spawnSync, } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { basename } from 'node:path';
+import { observability } from './observability.js';
+const owned = new Map();
+const byChild = new WeakMap();
+let exitHookInstalled = false;
+function audit(record, event, outcome, data) {
+    observability().record({
+        stage: 'daemon',
+        event,
+        outcome,
+        level: outcome === 'failed' ? 'warn' : 'info',
+        message: `${record.invocation} process ${event.replace('process.', '')}`,
+        correlation: record.correlation,
+        data: {
+            invocationId: record.invocationId,
+            invocation: record.invocation,
+            executable: basename(record.command),
+            pid: record.pid,
+            processGroup: record.processGroup,
+            elapsedMs: Date.now() - record.startedAt,
+            ...data,
+        },
+    });
+}
+function signalOwned(record, signal) {
+    try {
+        if (record.processGroup !== null)
+            process.kill(-record.processGroup, signal);
+        else if (!record.child.kill(signal))
+            return 'gone';
+        return 'sent';
+    }
+    catch (error) {
+        if (error.code === 'ESRCH')
+            return 'gone';
+        audit(record, 'process.signal_failed', 'failed', { signal, error: error instanceof Error ? error.message : String(error) });
+        return 'error';
+    }
+}
+function forceOwned(record, reason) {
+    if (!owned.has(record.pid))
+        return;
+    if (process.platform === 'win32') {
+        const result = spawnSync('taskkill', ['/pid', String(record.pid), '/t', '/f'], { stdio: 'ignore', windowsHide: true });
+        audit(record, 'process.signal', result.status === 0 ? 'succeeded' : 'failed', { reason, signal: 'taskkill-/t-/f', exitStatus: result.status });
+        return;
+    }
+    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)
+        return;
+    exitHookInstalled = true;
+    process.once('exit', () => {
+        for (const record of owned.values())
+            forceOwned(record, 'parent-shutdown');
+    });
+}
+function launchParentDeathSupervisor(pid, processGroup, graceMs) {
+    const posix = process.platform !== 'win32';
+    const script = posix ? [
+        "const pgid=Number(process.argv[1]),grace=Number(process.argv[2]);",
+        "const alive=()=>{try{process.kill(-pgid,0);return true}catch(e){return e&&e.code==='EPERM'}};",
+        "const stop=()=>{try{process.kill(-pgid,'SIGTERM')}catch{}setTimeout(()=>{try{process.kill(-pgid,'SIGKILL')}catch{}process.exit(0)},grace).unref()};",
+        "const timer=setInterval(()=>{if(!alive()){clearInterval(timer);process.exit(0);return}if(process.ppid===1){clearInterval(timer);stop()}},250);",
+    ].join('') : [
+        "const {spawnSync}=require('node:child_process'),owner=Number(process.argv[1]),pid=Number(process.argv[2]);",
+        "const alive=p=>{try{process.kill(p,0);return true}catch{return false}};",
+        "const timer=setInterval(()=>{if(!alive(pid)){clearInterval(timer);process.exit(0);return}if(!alive(owner)){clearInterval(timer);spawnSync('taskkill',['/pid',String(pid),'/t','/f'],{stdio:'ignore'});process.exit(0)}},250);",
+    ].join('');
+    const supervisorArgs = posix ? [String(processGroup), String(graceMs)] : [String(process.pid), String(pid)];
+    const supervisor = spawn(process.execPath, ['-e', script, ...supervisorArgs], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    supervisor.unref();
+    return supervisor;
+}
+/** Spawn one disposable Relay-owned process group. Arguments are intentionally excluded from audit logs. */
+export function spawnOwnedProcess(command, args, options) {
+    installExitHook();
+    if (options.signal?.aborted)
+        throw new Error(`${options.invocation} aborted before launch`);
+    const detached = process.platform !== 'win32';
+    const child = spawn(command, [...args], { ...options.spawn, detached });
+    if (!child.pid)
+        return child;
+    const record = {
+        child,
+        invocationId: randomUUID(),
+        invocation: options.invocation,
+        command,
+        pid: child.pid,
+        processGroup: detached ? child.pid : null,
+        startedAt: Date.now(),
+        graceMs: options.graceMs ?? 750,
+        correlation: options.correlation,
+        terminating: false,
+    };
+    owned.set(record.pid, record);
+    byChild.set(child, record);
+    record.supervisor = launchParentDeathSupervisor(record.pid, record.processGroup, record.graceMs);
+    audit(record, 'process.launched', 'started', {});
+    const abort = () => { void terminateOwnedProcess(child, 'abort'); };
+    record.abort = abort;
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.timeoutMs !== undefined) {
+        record.timeoutTimer = setTimeout(() => { void terminateOwnedProcess(child, 'timeout'); }, options.timeoutMs);
+        record.timeoutTimer.unref();
+    }
+    child.once('exit', (code, signal) => {
+        audit(record, 'process.exited', code === 0 ? 'succeeded' : 'failed', { exitStatus: code, signal });
+        // `close` waits for inherited stdio. End any descendants left behind by a
+        // wrapper before they can keep the caller alive indefinitely.
+        if (!record.terminating)
+            void terminateOwnedProcess(child, 'leader-exit');
+    });
+    child.once('close', () => {
+        if (record.timeoutTimer)
+            clearTimeout(record.timeoutTimer);
+        options.signal?.removeEventListener('abort', abort);
+        // The leader closing is not proof that its process group is gone.
+        // In particular, unref'd grandchildren need not inherit stdio.
+        // Preserve ownership and the force-kill timer through the grace window.
+        if (!record.terminating)
+            void terminateOwnedProcess(child, 'leader-exit');
+        setTimeout(() => {
+            if (record.forceTimer)
+                clearTimeout(record.forceTimer);
+            record.supervisor?.kill('SIGTERM');
+            owned.delete(record.pid);
+        }, record.graceMs + 100).unref();
+    });
+    return child;
+}
+export async function terminateOwnedProcess(child, reason, graceMs) {
+    const record = byChild.get(child);
+    if (!record || !owned.has(record.pid))
+        return;
+    if (!record.terminating) {
+        record.terminating = true;
+        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();
+    }
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    await new Promise(resolve => {
+        const fallback = setTimeout(resolve, (graceMs ?? record.graceMs) + 1000);
+        fallback.unref();
+        child.once('close', () => { clearTimeout(fallback); resolve(); });
+    });
+}
+export async function shutdownOwnedProcesses(reason = 'parent-shutdown') {
+    await Promise.allSettled([...owned.values()].map(record => terminateOwnedProcess(record.child, reason)));
+}
+export function ownedProcessSnapshot() {
+    return [...owned.values()].map(record => ({
+        invocationId: record.invocationId,
+        invocation: record.invocation,
+        pid: record.pid,
+        processGroup: record.processGroup,
+        elapsedMs: Date.now() - record.startedAt,
+    }));
+}

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

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
@@ -7,6 +6,7 @@ import { executionContextPrompt } from './execution-context.js';
 import { parseAgentGraph, validateAgentSelection } from './agent-graph.js';
 import { dispatchPlannerTrigger } from './workflow/planner-trigger-v2.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
+import { spawnOwnedProcess } from './owned-process.js';
 export function semanticTaskTree(tasks) {
     const work = tasks.filter(task => task.kind !== 'planner');
     const ids = new Set(work.map(task => task.id));
@@ -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')
@@ -384,11 +386,11 @@ export class CommandObjectivePlanner {
     }
     async plan(context, signal) {
         return await new Promise((resolve, reject) => {
-            const child = spawn(this.command, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+            const child = spawnOwnedProcess(this.command, [], { invocation: 'planner.command', signal, correlation: { jobId: context.job.id }, spawn: { stdio: ['pipe', 'pipe', 'pipe'] } });
             let stdout = '';
             let stderr = '';
-            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
-            child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+            child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
             child.on('error', reject);
             child.on('close', code => code === 0 ? (() => { try {
                 resolve(parsePlannerOutput(stdout));
@@ -396,8 +398,7 @@ export class CommandObjectivePlanner {
             catch (error) {
                 reject(error);
             } })() : reject(new Error(stderr.trim() || `Planner exited ${code}`)));
-            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
-            child.stdin.end(plannerInput(context));
+            child.stdin?.end(plannerInput(context));
         });
     }
 }
@@ -430,7 +431,7 @@ export class AgentObjectivePlanner {
         const resolvedContext = context.executionContext ? executionContextPrompt(context.executionContext) + '\n\n' : '';
         const prompt = instructions.trim() + '\n\n## Shared Task / Job Contract\n\n' + contract.trim() + '\n\n' + resolvedContext + '## Durable planner input\n\n' + plannerInput(context);
         return await new Promise((resolve, reject) => {
-            const child = spawn(this.command, ['exec', '--json', '--', prompt], { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] });
+            const child = spawnOwnedProcess(this.command, ['exec', '--json', '--', prompt], { invocation: 'planner.agent', signal, correlation: { jobId: context.job.id }, spawn: { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] } });
             let stdoutBuffer = '';
             let finalMessage = '';
             let stderrTail = '';
@@ -439,14 +440,14 @@ export class AgentObjectivePlanner {
                 if (message)
                     finalMessage = message;
             };
-            child.stdout.on('data', (chunk) => {
+            child.stdout?.on('data', (chunk) => {
                 stdoutBuffer += chunk.toString();
                 const lines = stdoutBuffer.split(/\r?\n/);
                 stdoutBuffer = lines.pop() ?? '';
                 for (const line of lines)
                     consume(line);
             });
-            child.stderr.on('data', (chunk) => { stderrTail = (stderrTail + chunk.toString()).slice(-16384); });
+            child.stderr?.on('data', (chunk) => { stderrTail = (stderrTail + chunk.toString()).slice(-16384); });
             child.on('error', reject);
             child.on('close', code => {
                 if (stdoutBuffer)
@@ -466,7 +467,6 @@ export class AgentObjectivePlanner {
                     reject(error);
                 }
             });
-            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
         });
     }
 }

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) {
@@ -54,6 +56,7 @@ export class ReconcilerRuntimeBase {
     continuationLive = new Set();
     launchFailureClaims = new Set();
     terminalWaiters = new Map();
+    startAckCleanups = new Set();
     taskTransitions;
     eventCoordinator;
     detachedReconciles = new Set();
@@ -155,6 +158,7 @@ export class ReconcilerRuntimeBase {
         await this.eventCoordinator.settle();
         if (this.detachedReconciles.size > 0)
             await Promise.allSettled([...this.detachedReconciles]);
+        await Promise.allSettled([...this.startAckCleanups].map(stop => stop()));
         for (const live of this.live.values()) {
             const sourceId = executionEventSource(live.jobId, live.taskId, live.executionId);
             if (activeExecutionOwners.get(sourceId) === this)
@@ -204,13 +208,27 @@ export class ReconcilerRuntimeBase {
             rejectAck(new StartAckTimeout(`Task ${taskId} worker_start_timeout: no worker task.started start-ack`));
         }, timeoutMs);
         let stopped = false;
-        const stop = async () => { if (stopped)
-            return; stopped = true; if (timer)
-            clearTimeout(timer); await unsubscribe(); };
+        const stop = async () => {
+            if (stopped)
+                return;
+            stopped = true;
+            if (timer)
+                clearTimeout(timer);
+            if (!settled) {
+                settled = true;
+                rejectAck(new StartAckTimeout(`Task ${taskId} worker_start_cancelled: start-ack owner closed`));
+            }
+            this.startAckCleanups.delete(stop);
+            await unsubscribe();
+        };
+        this.startAckCleanups.add(stop);
         return { ack, stop };
     }
     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)
@@ -323,9 +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);
-        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', error ? 'failed' : 'succeeded', error ?? result?.summary ?? 'Worker runtime exited', 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, processError: error }, { agent: 'relay', component: 'agents-relay' }));
+        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, 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(?,?,?,?)