agents-relay 1.0.103 → 1.0.104

package/dist/agent-graph.js

@@ -66,8 +66,22 @@ export function parseAgentGraph(source) {
         throw new Error('Agent Graph contains a cycle');
     return { source, nodes: [...agents].map(([id, agent]) => ({ id, agent })), edges, waves };
 }
+export function validateAgentSelection(context, agentName, agentGraph) {
+    const visible = new Set(context.agents.map(agent => agent.name));
+    if (agentName && !visible.has(agentName)) {
+        throw new Error(`Agent ${agentName} is not visible in the resolved planning/execution context`);
+    }
+    if (!agentGraph)
+        return;
+    for (const node of parseAgentGraph(agentGraph).nodes) {
+        if (!visible.has(node.agent)) {
+            throw new Error(`Agent ${node.agent} referenced by agentGraph node ${node.id} is not visible in the resolved planning/execution context`);
+        }
+    }
+}
 export async function agentGraphPrompt(context, source) {
     const graph = parseAgentGraph(source);
+    validateAgentSelection(context, undefined, source);
     const contracts = await Promise.all(graph.nodes.map(async (node) => ({ node, prompt: await agentContractPrompt(context, node.agent) })));
     const incoming = new Map(graph.nodes.map(node => [node.id, graph.edges.filter(edge => edge.to === node.id).map(edge => edge.from)]));
     return `[Task Agent Graph]\n${source.trim()}\n\nExecution waves: ${graph.waves.map((wave, index) => `${index + 1}:${wave.join(',')}`).join(' | ')}\n\nExecute this graph inside the current durable Task. Nodes are reasoning roles, NOT durable child Tasks. Preserve the original Job/Task context for every node. Nodes in the same wave are independent: evaluate each from the same original context without using sibling prose. For each later node, provide the original context plus structured outputs only from its declared predecessors. Do not emit outer task.started or task terminal events per node; the current durable Task owns exactly one start and one terminal event.\n\n${contracts.map(({ node, prompt }) => `[Node ${node.id}; predecessors=${(incoming.get(node.id) ?? []).join(',') || 'none'}]\n${prompt}`).join('\n\n')}`;

package/dist/cli-help.js

@@ -156,10 +156,12 @@ Common: --task-id ID, --commit SHA, --project NAME.
 
 Example:
   npx agents-relay record --file .agents-relay.json --summary "Built release" --commit abc123`,
-    reconcile: `Reconcile a job once, launching ready tasks and persisting results.
+    reconcile: `Reconcile a job once by requesting one reconciliation pass.
 
 Required: --file PATH for local demo mode, or --repo OWNER/REPO --pr NUMBER --id JOB_ID.
 
+Managed GitHub jobs are reconciled by agents-relayd. The CLI publishes a job.wake request and does not launch workers; use --events nats.
+
 Example:
   npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1`,
     tick: `Process autonomous jobs indexed into current/recent GitHub next-run buckets.

package/dist/cli-support.js

@@ -74,6 +74,16 @@ export async function publishWake(bus, job, taskId, message) { if (!bus)
 catch (error) {
     process.stderr.write(`warning: event wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
 } }
+export async function requestManagedReconciliation(bus, job) {
+    if (!bus)
+        throw new Error('Managed GitHub reconciliation requires --events nats so agents-relayd can execute the job');
+    try {
+        await bus.publish(eventFor(job.id, 'reconcile', null, 'job.wake', 'queued', `Reconcile requested for ${job.id}`, 'orchestrator', { repository: job.repository, prNumber: job.prNumber }));
+    }
+    catch (error) {
+        throw new Error(`Unable to deliver managed reconciliation wake to agents-relayd: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 export function priority(args, fallback = 'P2') { const value = arg(args, '--priority', fallback); if (!['P0', 'P1', 'P2', 'P3'].includes(value))
     throw new Error('--priority must be P0, P1, P2, or P3'); return value; }
 export function storySize(args, fallback = 'M') { const value = arg(args, '--story-size', fallback).toUpperCase(); if (!['S', 'M', 'L'].includes(value))

package/dist/cli.js

@@ -22,7 +22,7 @@ import { defaultWorkspaceRoot, resolveManagedProjectPath } from './workspace.js'
 import { runBlockerCommand } from './cli-blocker.js';
 import { helpText, usage } from './cli-help.js';
 export { helpText } from './cli-help.js';
-import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, } from './cli-support.js';
+import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, requestManagedReconciliation, } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
 export async function ensureManagedGitHubJob(client, repositoryName, trustedAuthors, options) {
     if (!options.id)
@@ -646,6 +646,16 @@ async function main() {
         console.log(JSON.stringify(await store.load(job.id), null, 2));
         return;
     }
+    if (command === 'reconcile' && !localFile) {
+        try {
+            await requestManagedReconciliation(bus, job);
+            console.log(JSON.stringify(await store.load(job.id), null, 2));
+        }
+        finally {
+            await bus?.close?.();
+        }
+        return;
+    }
     const reconciler = runtime(store, args, bus);
     if (command === 'reconcile') {
         await reconciler.reconcile(job.id);

package/dist/dashboard-html.js

@@ -1,3 +1,5 @@
+import { createRequire } from 'node:module';
+const packageVersion = createRequire(import.meta.url)('../package.json').version;
 export const dashboardHtml = `<!doctype html>
 <html lang="en" data-dashboard-contract="safe-dom,named-relay-events,snapshot-events,bounded-event-history">
 <head>
@@ -11,6 +13,7 @@ export const dashboardHtml = `<!doctype html>
     body { margin:0; min-height:100vh; background:var(--bg); color:var(--text); font:14px/1.45 ui-sans-serif,system-ui,sans-serif; }
     header { position:sticky; top:0; z-index:3; background:var(--surface); border-bottom:1px solid var(--border); padding:.8rem 1rem; }
     .brand { display:flex; align-items:baseline; gap:.65rem; min-width:0; }
+    .version { margin-left:auto; color:var(--muted); font-size:.72rem; font-family:ui-monospace,SFMono-Regular,Menlo,monospace; white-space:nowrap; }
     h1 { margin:0; font-size:1.08rem; letter-spacing:-.02em; }
     .tagline,.subtle { color:var(--muted); font-size:.78rem; }
     .warning-banner { margin:.65rem 0 0; padding:.5rem .65rem; border:1px solid #e6bf62; border-radius:.4rem; background:#fff4d6; color:#6f4b00; font-size:.78rem; font-weight:700; }
@@ -83,7 +86,13 @@ export const dashboardHtml = `<!doctype html>
     .event-meta { display:flex; flex-wrap:wrap; gap:.4rem; color:var(--muted); font-size:.68rem; }
     .event-kind { color:var(--accent); font-weight:800; }
     .event-message { margin:.12rem 0 0; overflow-wrap:anywhere; }
-    #usage-view { grid-column:1 / -1; }
+    #usage-view,#rules-view { grid-column:1 / -1; }
+    .rules-editor { display:grid; gap:.65rem; }
+    .rules-help { margin:0; color:var(--muted); font-size:.8rem; }
+    .rules-textarea { width:100%; min-height:55vh; resize:vertical; border:1px solid var(--border); border-radius:.45rem; background:var(--surface2); color:var(--text); padding:.8rem; font:13px/1.55 ui-monospace,SFMono-Regular,Menlo,monospace; }
+    .rules-footer { display:flex; align-items:center; justify-content:space-between; gap:.75rem; flex-wrap:wrap; }
+    .rules-save { border:1px solid var(--accent); border-radius:.35rem; background:var(--accent); color:#fff; padding:.38rem .8rem; font:inherit; font-weight:750; cursor:pointer; }
+    .rules-save:disabled { opacity:.55; cursor:default; }
     .usage-providers { display:grid; gap:.55rem; }
     .usage-provider { display:grid; grid-template-columns:minmax(130px,180px) minmax(0,1fr); gap:1rem; align-items:center; padding:.7rem .8rem; border:1px solid var(--border); border-radius:.45rem; background:var(--surface2); }
     .usage-provider h3 { margin:0; font-size:.86rem; }
@@ -103,11 +112,12 @@ export const dashboardHtml = `<!doctype html>
 </head>
 <body>
 <header>
-  <div class="brand"><h1>Agents Relay Console</h1><p class="tagline">Durable PR state is authoritative; events are observability.</p></div>
+  <div class="brand"><h1>Agents Relay Console</h1><p class="tagline">Durable PR state is authoritative; events are observability.</p><span class="version">v${packageVersion}</span></div>
   <div id="rate-limit-warning" class="warning-banner" role="status" hidden></div>
   <nav role="tablist" aria-label="Console views">
     <button id="jobs-tab" type="button" role="tab" aria-selected="true" aria-controls="jobs-view">Jobs</button>
     <button id="usage-tab" type="button" role="tab" aria-selected="false" aria-controls="usage-view">Usage</button>
+    <button id="rules-tab" type="button" role="tab" aria-selected="false" aria-controls="rules-view">Model Router Rules</button>
   </nav>
 </header>
 <main>
@@ -137,6 +147,18 @@ export const dashboardHtml = `<!doctype html>
       <div class="panel-body" id="usage-root" aria-live="polite"><div class="skeleton"></div></div>
     </div>
   </section>
+  <section id="rules-view" role="tabpanel" aria-labelledby="rules-tab" hidden>
+    <div class="panel">
+      <div class="panel-head"><h2>Model Router Rules</h2><span id="rules-meta" class="subtle"></span></div>
+      <div class="panel-body">
+        <div class="rules-editor">
+          <p class="rules-help">Free-text guidance loaded by the model decider for every routing decision. Hard capability and health gates remain enforced by code.</p>
+          <textarea id="rules-text" class="rules-textarea" spellcheck="true" aria-label="Model router rules" placeholder="Example: Prefer ZAI when paid quota is abundant and task quality is sufficient. If a provider/runtime path just failed, reconsider using the failure evidence and fresh usage."></textarea>
+          <div class="rules-footer"><span id="rules-status" class="subtle" aria-live="polite"></span><button id="rules-save" class="rules-save" type="button">Save rules</button></div>
+        </div>
+      </div>
+    </div>
+  </section>
 </main>
 <script>
 'use strict';
@@ -155,8 +177,10 @@ export const dashboardHtml = `<!doctype html>
 const MAX_EVENTS=60;
 const jobsTab=document.querySelector('#jobs-tab');
 const usageTab=document.querySelector('#usage-tab');
+const rulesTab=document.querySelector('#rules-tab');
 const jobsView=document.querySelector('#jobs-view');
 const usageView=document.querySelector('#usage-view');
+const rulesView=document.querySelector('#rules-view');
 const jobsWorkspace=document.querySelector('#jobs-workspace');
 const jobList=document.querySelector('#job-list');
 const jobsRefresh=document.querySelector('#jobs-refresh');
@@ -176,6 +200,10 @@ const connection=document.querySelector('#connection');
 const selectedJobTitle=document.querySelector('#selected-job-title');
 const usageRoot=document.querySelector('#usage-root');
 const usageMeta=document.querySelector('#usage-meta');
+const rulesText=document.querySelector('#rules-text');
+const rulesMeta=document.querySelector('#rules-meta');
+const rulesStatus=document.querySelector('#rules-status');
+const rulesSave=document.querySelector('#rules-save');
 const rateLimitWarning=document.querySelector('#rate-limit-warning');
 let jobs=[];
 let selectedJob=sessionStorage.getItem('agents-relay:selected-job');
@@ -266,7 +294,9 @@ function usageProvider(provider){const card=element('section','usage-provider');
 function formatCredit(value,currency){if(value===null||value===undefined||!Number.isFinite(Number(value)))return '—';const number=Number(value);if(currency==='USD')return '$'+number.toFixed(2);if(currency==='CNY')return '¥'+number.toFixed(2);return number.toFixed(2)+' '+currency;}
 function creditProvider(provider){const row=element('section','usage-provider');row.append(element('h3','',text(provider.label)));const credits=provider.credits||{};if(!credits.available||!Array.isArray(credits.balances)||!credits.balances.length){row.append(element('p','empty',text(credits.reason||'Credit balance is unavailable.')));return row;}const balance=credits.balances[0];row.append(element('div','detail-value',text(formatCredit(balance.remaining,balance.currency))));return row;}
 async function drawUsage(){try{const overview=await loadJSON('/api/usage');usageRoot.replaceChildren();usageMeta.textContent='Real account telemetry when available';const providers=Array.isArray(overview.providers)?overview.providers:[];const credits=Array.isArray(overview.credits)?overview.credits:[];if(!providers.length&&!credits.length){usageRoot.append(element('p','empty',text('Usage telemetry is unavailable.')));return;}const grid=element('div','usage-providers');for(const provider of providers)grid.append(usageProvider(provider));for(const provider of credits)grid.append(creditProvider(provider));usageRoot.append(grid);}catch(error){usageMeta.textContent='Unavailable';usageRoot.replaceChildren(element('p','error-state',text('Usage unavailable: '+error.message)));}}
-function showView(view){const isJobs=view==='jobs';jobsView.hidden=!isJobs;jobsWorkspace.hidden=!isJobs;usageView.hidden=isJobs;jobsTab.setAttribute('aria-selected',String(isJobs));usageTab.setAttribute('aria-selected',String(!isJobs));if(isJobs)void refresh();else void drawUsage();}
+async function drawRules(){rulesStatus.textContent='';try{const rules=await loadJSON('/api/model-router-rules');rulesText.value=typeof rules.text==='string'?rules.text:'';rulesMeta.textContent=rules.hash&&rules.hash!=='none'?'Loaded · '+rules.hash.slice(0,12):'No custom rules saved';}catch(error){rulesMeta.textContent='Unavailable';rulesStatus.textContent='Could not load rules: '+error.message;}}
+async function saveRules(){rulesSave.disabled=true;rulesStatus.textContent='Saving…';try{const response=await fetch('/api/model-router-rules',{method:'PUT',headers:{'content-type':'text/plain; charset=utf-8'},body:rulesText.value});if(!response.ok)throw new Error(response.status+' '+await response.text());const rules=await response.json();rulesMeta.textContent='Saved · '+rules.hash.slice(0,12);rulesStatus.textContent='Saved. New routing decisions will load these rules.';}catch(error){rulesStatus.textContent='Save failed: '+error.message;}finally{rulesSave.disabled=false;}}
+function showView(view){const isJobs=view==='jobs';const isUsage=view==='usage';const isRules=view==='rules';jobsView.hidden=!isJobs;jobsWorkspace.hidden=!isJobs;usageView.hidden=!isUsage;rulesView.hidden=!isRules;jobsTab.setAttribute('aria-selected',String(isJobs));usageTab.setAttribute('aria-selected',String(isUsage));rulesTab.setAttribute('aria-selected',String(isRules));if(isJobs)void refresh();else if(isUsage)void drawUsage();else void drawRules();}
 jobsTab.addEventListener('click',()=>{location.hash=selectedJob?'#/jobs/'+encodeURIComponent(selectedJob):'#/jobs';showView('jobs');});
 jobsRefresh.addEventListener('click',()=>void refresh(true));
 eventsAllTasks.addEventListener('click',()=>{eventTaskId=null;clearEvents();renderEventScope();void loadEventHistory();});
@@ -277,15 +307,17 @@ quickDraft.addEventListener('click',()=>toggleQuickMode('draft'));
 quickStatus.addEventListener('change',()=>setQuickMode(quickStatus.value?'status':'jobs',quickStatus.value));
 selectedJobRefresh.addEventListener('click',()=>void refreshSelected());
 usageTab.addEventListener('click',()=>{location.hash='#/usage';showView('usage');});
-window.addEventListener('keydown',event=>{if(event.key==='Tab'&&event.altKey){event.preventDefault();showView(location.hash==='#/usage'?'jobs':'usage');}});
+rulesTab.addEventListener('click',()=>{location.hash='#/model-router-rules';showView('rules');});
+rulesSave.addEventListener('click',()=>void saveRules());
+window.addEventListener('keydown',event=>{if(event.key==='Tab'&&event.altKey){event.preventDefault();const next=location.hash==='#/usage'?'rules':location.hash==='#/model-router-rules'?'jobs':'usage';location.hash=next==='usage'?'#/usage':next==='rules'?'#/model-router-rules':(selectedJob?'#/jobs/'+encodeURIComponent(selectedJob):'#/jobs');showView(next);}});
 function parseMessage(message){try{return JSON.parse(message.data);}catch{return null;}}
 const stream=new EventSource('/events');
 stream.onopen=()=>{connection.textContent='';connection.setAttribute('aria-label','Event stream connected');connection.className='status-pill ok';};
 stream.onerror=()=>{connection.textContent='';connection.setAttribute('aria-label','Event stream reconnecting');connection.className='status-pill warn';};
 stream.onmessage=message=>{const payload=parseMessage(message);if(payload?.job){const index=jobs.findIndex(job=>job.id===payload.job.id);if(index>=0)jobs[index]=payload.job;else jobs.push(payload.job);renderAll();}};
 stream.addEventListener('relay',message=>{const payload=parseMessage(message);if(payload?.job){const index=jobs.findIndex(job=>job.id===payload.job.id);if(index>=0)jobs[index]=payload.job;else jobs.push(payload.job);}if(payload?.event)addEvent(payload.event);renderAll();});
-if(location.hash==='#/usage')showView('usage');else showView('jobs');
-setInterval(()=>{if(location.hash!=='#/usage')void refresh();},300000);
+if(location.hash==='#/usage')showView('usage');else if(location.hash==='#/model-router-rules')showView('rules');else showView('jobs');
+setInterval(()=>{if(location.hash!=='#/usage'&&location.hash!=='#/model-router-rules')void refresh();},300000);
 setInterval(()=>{if(location.hash==='#/usage')void drawUsage();},30000);
 async function refreshSelected(){if(!selectedJob){await refresh();return;}selectedJobRefresh.disabled=true;selectedJobRefresh.textContent='Refreshing…';try{const updated=await loadJSON('/api/job?id='+encodeURIComponent(selectedJob));const index=jobs.findIndex(job=>job.id===selectedJob);if(index>=0)jobs[index]=updated;else jobs.push(updated);rememberSelection();renderAll();connection.textContent='';connection.setAttribute('aria-label','Live durable state connected');connection.className='status-pill ok';}catch(error){connection.textContent='';connection.setAttribute('aria-label','Durable state unavailable');connection.className='status-pill bad';}finally{selectedJobRefresh.disabled=false;selectedJobRefresh.textContent='Refresh';}}
 </script>

package/dist/dashboard.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { readUsageSnapshot } from './usage.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
+import { loadModelRouterRules, saveModelRouterRules } from './routing-policy.js';
 const GITHUB_REPOSITORY_PATTERN = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
 const SSE_HEARTBEAT_MS = 15000;
 const EVENTS_HISTORY_FILE = process.env.EVENTS_BUS_DATA_DIR ? join(process.env.EVENTS_BUS_DATA_DIR, 'events.jsonl') : join(homedir(), 'Library', 'Application Support', 'EventsBus', 'events.jsonl');
@@ -267,6 +268,47 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.end(JSON.stringify(events));
             return;
         }
+        if (req.url === '/api/model-router-rules') {
+            if (req.method === 'GET') {
+                try {
+                    const rules = await loadModelRouterRules();
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify(rules));
+                }
+                catch (error) {
+                    res.writeHead(500);
+                    res.end(error instanceof Error ? error.message : String(error));
+                }
+                return;
+            }
+            if (req.method === 'PUT') {
+                const chunks = [];
+                let size = 0;
+                for await (const chunk of req) {
+                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    size += buffer.length;
+                    if (size > 64 * 1024) {
+                        res.writeHead(413);
+                        res.end('Model router rules exceed 64 KiB');
+                        return;
+                    }
+                    chunks.push(buffer);
+                }
+                try {
+                    const rules = await saveModelRouterRules(Buffer.concat(chunks).toString('utf8'));
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify(rules));
+                }
+                catch (error) {
+                    res.writeHead(500);
+                    res.end(error instanceof Error ? error.message : String(error));
+                }
+                return;
+            }
+            res.writeHead(405, { allow: 'GET, PUT' });
+            res.end('Method not allowed');
+            return;
+        }
         if (req.url === '/api/status') {
             const status = statusProvider ? statusProvider() : { limited: false, cooldownUntil: null };
             res.writeHead(200, { 'content-type': 'application/json' });

package/dist/decision-audit.js

@@ -0,0 +1,58 @@
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { randomUUID, createHash } from 'node:crypto';
+export const DECISION_AUDIT_SCHEMA_VERSION = 2;
+export class JsonlDecisionAuditStore {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    async append(record) { await mkdir(dirname(this.path), { recursive: true }); await appendFile(this.path, `${JSON.stringify(sanitize(record))}\n`, 'utf8'); }
+    async read() {
+        try {
+            return (await readFile(this.path, 'utf8')).split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+function sanitize(value, key = '') {
+    if (/(token|secret|password|credential|authorization|api.?key)/i.test(key))
+        return '[redacted]';
+    if (Array.isArray(value))
+        return value.map(item => sanitize(item));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, sanitize(v, k)]));
+    return value;
+}
+export function decisionAuditId() { return randomUUID(); }
+export function auditInputHash(record) { return createHash('sha256').update(JSON.stringify(record)).digest('hex'); }
+export function outcomeForDecision(decisionId, kind, summary, evidence) { return { record_type: 'outcome', schema_version: DECISION_AUDIT_SCHEMA_VERSION, outcome_id: randomUUID(), decision_id: decisionId, timestamp: new Date().toISOString(), kind, summary, evidence }; }
+export function taskAuditFacts(task) {
+    if (!task)
+        return {};
+    return { job_id: task.jobId, task_id: task.id, attempt: task.attempt, execution_id: task.executionId, capabilities: [...task.capabilities], input_class: task.input.slice(0, 80).replace(/\s+/g, ' ') };
+}
+export function makeDecisionAudit(input) {
+    const candidate = (item) => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null });
+    const eligibleIds = new Set(input.eligibleCandidates.map(item => item.id));
+    const gate_results = input.candidates.map(item => {
+        const reasons = [];
+        if (item.resourceHealthy === false)
+            reasons.push('resource_unhealthy');
+        const constraints = input.contract.constraints;
+        if (typeof constraints?.provider === 'string' && constraints.provider !== item.provider)
+            reasons.push('provider_constraint');
+        if (typeof constraints?.model === 'string' && constraints.model !== item.model)
+            reasons.push('model_constraint');
+        if (typeof constraints?.profile === 'string' && constraints.profile !== item.profile)
+            reasons.push('profile_constraint');
+        if (input.policy.policy.disabledProviders?.includes(item.provider))
+            reasons.push('policy_disabled_provider');
+        if (item.profile && input.policy.policy.disabledProfiles?.includes(item.profile))
+            reasons.push('policy_disabled_profile');
+        return { candidate_id: item.id, eligible: eligibleIds.has(item.id), rejection_reasons: reasons };
+    });
+    return { record_type: 'decision', schema_version: DECISION_AUDIT_SCHEMA_VERSION, decision_id: decisionAuditId(), prior_decision_id: input.priorDecisionId, timestamp: input.routing.decidedAt, correlation: { job_id: input.task?.jobId, task_id: input.task?.id, execution_id: input.task?.executionId, attempt: input.task?.attempt }, task: taskAuditFacts(input.task), worker: input.worker, contract: input.contract, policy: { path: input.policy.path, hash: input.policy.hash, snapshot: input.policy.snapshot, rules: input.policy.rules }, candidates: input.candidates.map(candidate), gate_results, eligible_candidates: input.eligibleCandidates.map(candidate), selected: candidate(input.selected), engine: input.routing.decidedBy, fallback: { used: input.routing.decisionEvidence?.fallback ?? false, reason: input.routing.decisionEvidence?.error }, decision_evidence: input.routing.decisionEvidence, prior_failure: input.priorFailure };
+}

package/dist/execution-context.js

@@ -258,6 +258,7 @@ export function executionContextPrompt(context) {
     const skills = context.skills.map(item => `- ${item.name}: ${item.path} [${item.source}]`).join('\n') || '- none';
     const agents = context.agents.map(item => {
         const details = [
+            item.description ? `purpose=${item.description}` : '',
             item.capabilities.length ? `capabilities=${item.capabilities.join(',')}` : '',
             item.runtime ? `runtime=${item.runtime}` : '',
             item.trustDomains.length ? `trust=${item.trustDomains.join(',')}` : '',

package/dist/model-redecision.js

@@ -0,0 +1,41 @@
+import { outcomeForDecision } from './decision-audit.js';
+import { discoverModelCandidates, routeModel } from './model-routing.js';
+import { readUsageSnapshot } from './usage.js';
+/** Classify from durable lifecycle evidence and logs; task.error is only a supporting hint. */
+export function classifyFailureEvidence(input) {
+    const text = [...input.events.map(event => `${event.type} ${event.message ?? ''} ${JSON.stringify(event.data ?? {})}`), ...(input.logs ?? [])].join('\n').toLowerCase();
+    const model = /model|provider|laya|launch|auth|credential|configuration|incompatible|rate.?limit|quota|unavailable/.test(text);
+    const infra = /worker|tool|daemon|relay|network|socket|nats|checkout|filesystem/.test(text);
+    const semantic = /assert|test failed|implementation|compile|typescript|syntax|semantic/.test(text);
+    const timeout = /timeout|timed out|deadline/.test(text);
+    if (model && !infra)
+        return { classification: 'model_provider_runtime', summary: 'Durable events/logs indicate the selected model/provider/runtime path failed.', sources: ['task.events', 'worker.logs'] };
+    if (infra)
+        return { classification: 'worker_tool_infrastructure', summary: 'Durable events/logs indicate worker, tool, or infrastructure failure unrelated to model choice.', sources: ['task.events', 'worker.logs'] };
+    if (semantic)
+        return { classification: 'semantic_task', summary: 'Durable events/logs indicate meaningful task execution failed semantically.', sources: ['task.events', 'worker.logs'] };
+    if (timeout)
+        return { classification: 'timeout_unknown', summary: 'Timeout evidence is insufficient to attribute failure to model choice.', sources: ['task.events', 'worker.logs'] };
+    return { classification: 'timeout_unknown', summary: input.events.length === 0 && !input.logs?.length ? 'No durable event or log evidence was supplied.' : 'Failure attribution is unknown from the available evidence.', sources: ['task.events', 'worker.logs'] };
+}
+/** Re-route only. This action never retries or changes the Task lifecycle. */
+export async function redecideFailedTask(options) {
+    if (options.evidence.classification !== 'model_provider_runtime')
+        throw new Error('Model re-decision requires model/provider/runtime evidence');
+    const usage = await readUsageSnapshot(options.usage);
+    const candidates = await discoverModelCandidates(options.worker, options.registered, usage);
+    const result = await routeModel(options.worker, candidates, {
+        decisionEngine: options.decisionEngine,
+        decisionMode: options.decisionMode,
+        policyPath: options.policyPath,
+        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 },
+        priorDecisionId: options.task.routing?.decisionId,
+        priorFailure: options.evidence,
+    });
+    await options.updateRouting(options.task, result.routing);
+    if (options.auditStore && options.task.routing?.decisionId)
+        await options.auditStore.append(outcomeForDecision(options.task.routing.decisionId, 'provider_failure', options.evidence.summary, { classification: options.evidence.classification, fresh_usage_generated_at: usage.generatedAt }));
+    return { ...result, freshUsageGeneratedAt: usage.generatedAt };
+}

package/dist/model-routing.js

@@ -3,6 +3,8 @@ import { basename, join } from 'node:path';
 import { readdir, readFile } from 'node:fs/promises';
 import { chooseWithDecision } from './decision.js';
 import { usageForProvider } from './worker-routing.js';
+import { makeDecisionAudit } from './decision-audit.js';
+import { loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
 function topLevelCodexConfig(text) {
     const result = {};
     let inSection = false;
@@ -73,10 +75,12 @@ export async function discoverModelCandidates(worker, registered, usage, codexHo
         candidates.push(withResource({ id: 'default:openai/gpt-5.6-luna', provider: 'openai', model: 'gpt-5.6-luna' }, usage));
     return candidates.filter((candidate, index, all) => all.findIndex(item => item.id === candidate.id) === index);
 }
-function eligibleModels(candidates, constraints) {
+function eligibleModels(candidates, constraints, policy) {
     return candidates.filter(candidate => {
         if (candidate.resourceHealthy === false)
             return false;
+        if (policy && !policyAllows(candidate, policy.policy))
+            return false;
         if (constraints?.provider && candidate.provider !== constraints.provider)
             return false;
         if (constraints?.model && candidate.model !== constraints.model)
@@ -88,37 +92,59 @@ function eligibleModels(candidates, constraints) {
         return true;
     });
 }
-function deterministicModel(candidates) {
+function deterministicModel(candidates, taskKind, policy) {
     return [...candidates].map((candidate, index) => ({ candidate, index })).sort((left, right) => {
         const pressure = (item) => item.resourceUsedPercent === undefined ? 1 : item.resourceUsedPercent >= 90 ? 2 : 0;
-        return pressure(left.candidate) - pressure(right.candidate) || left.index - right.index;
+        return pressure(left.candidate) - pressure(right.candidate) || (policy ? policyRank(right.candidate, taskKind, policy.policy) - policyRank(left.candidate, taskKind, policy.policy) : 0) || left.index - right.index;
     })[0].candidate;
 }
 export async function routeModel(worker, candidates, options = {}) {
-    const eligible = eligibleModels(candidates, options.constraints);
+    const policy = await loadRoutingPolicy(options.policyPath, options.rulesPath);
+    const eligible = eligibleModels(candidates, options.constraints, policy);
     if (eligible.length === 0)
         throw new Error(`No eligible model profile is usable by worker ${worker.workerId}`);
-    const deterministic = deterministicModel(eligible);
+    const taskKind = typeof options.taskFacts?.kind === 'string' ? options.taskFacts.kind : undefined;
+    const deterministic = deterministicModel(eligible, taskKind, policy);
     const choice = eligible.length === 1
         ? { choice: deterministic.id, evidence: { mode: options.decisionMode ?? 'off', fallback: true } }
         : await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', {
             facts: JSON.parse(JSON.stringify({
                 task: options.taskFacts ?? {},
+                environment_policy: { structured_policy: policy.snapshot, rules: policy.rules.text },
+                prior_decision_id: options.priorDecisionId ?? null,
+                prior_failure: options.priorFailure ?? null,
                 worker: { id: worker.workerId, adapter: worker.adapter, capabilities: [...worker.capabilities] },
                 candidates: eligible.map(item => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null })),
             })),
-        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task? Prefer spending otherwise-expiring paid quota on stronger reasoning when reset is near and substantial capacity remains, but consider every quota window so a tighter longer-horizon limit is not needlessly depleted; never violate task fit or continuity.', choices: eligible.map(item => item.id) }, () => deterministic.id);
+        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task? Apply hard gates first, then explicit task constraints, then current environment policy; consider every quota window and never violate task fit or continuity.', choices: eligible.map(item => item.id) }, () => deterministic.id);
     const selected = eligible.find(item => item.id === choice.choice) ?? deterministic;
+    const routing = {
+        provider: selected.provider,
+        model: selected.model,
+        profile: selected.profile,
+        reasoning: options.constraints?.reasoning ?? selected.reasoning,
+        decidedBy: choice.evidence.engine && !choice.evidence.fallback ? 'model-router:laya' : 'model-router',
+        decidedAt: new Date().toISOString(),
+        decisionEvidence: choice.evidence,
+    };
+    const audit = makeDecisionAudit({
+        task: options.auditTask,
+        worker: { id: worker.workerId, adapter: worker.adapter, capabilities: [...worker.capabilities] },
+        contract: { question: 'model-profile-selection', task: options.taskFacts ?? {}, constraints: options.constraints ?? {} },
+        policy,
+        candidates,
+        eligibleCandidates: eligible,
+        selected,
+        routing,
+        priorDecisionId: options.priorDecisionId,
+        priorFailure: options.priorFailure,
+    });
+    routing.decisionId = audit.decision_id;
+    if (options.auditStore)
+        await options.auditStore.append(audit);
     return {
         candidate: selected,
-        routing: {
-            provider: selected.provider,
-            model: selected.model,
-            profile: selected.profile,
-            reasoning: options.constraints?.reasoning ?? selected.reasoning,
-            decidedBy: choice.evidence.engine && !choice.evidence.fallback ? 'model-router:laya' : 'model-router',
-            decidedAt: new Date().toISOString(),
-            decisionEvidence: choice.evidence,
-        },
+        routing,
+        audit,
     };
 }

package/dist/planner.js

@@ -140,7 +140,14 @@ export function parsePlannerOutput(output) {
     return parsePlannerResult(JSON.parse(candidate));
 }
 export function plannerInput(context) {
-    return JSON.stringify({ objective: context.objective, previous_planner_task_id: context.previousPlannerTaskId, execution_context: context.executionContext, tasks: context.tasks.map(task => ({ id: task.id, kind: task.kind ?? 'work', parent_task_id: task.parentTaskId, state: task.state, input: task.input, result: task.result, planner_result: task.plannerResult, error: task.error })) });
+    const visibleAgents = context.executionContext?.agents.map(agent => ({
+        name: agent.name,
+        description: agent.description,
+        capabilities: agent.capabilities,
+        boundaries: agent.restrictions,
+        runtime: agent.runtime,
+    }));
+    return JSON.stringify({ objective: context.objective, previous_planner_task_id: context.previousPlannerTaskId, visible_agents: visibleAgents ?? [], execution_context: context.executionContext, tasks: context.tasks.map(task => ({ id: task.id, kind: task.kind ?? 'work', parent_task_id: task.parentTaskId, state: task.state, input: task.input, result: task.result, planner_result: task.plannerResult, error: task.error })) });
 }
 export class CommandObjectivePlanner {
     command;

package/dist/reconciler-review.js

@@ -114,7 +114,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             const routedWorker = await routeWorker(candidates, requirements, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts });
             const models = await discoverModelCandidates(routedWorker.candidate, registered, usage);
             const routingConstraints = task.routing ? { provider: task.routing.provider, model: task.routing.model, profile: task.routing.profile, reasoning: task.routing.reasoning } : undefined;
-            const routedModel = await routeModel(routedWorker.candidate, models, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts, constraints: routingConstraints });
+            const routedModel = await routeModel(routedWorker.candidate, models, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts, constraints: routingConstraints, auditStore: this.options.decisionAuditStore, auditTask: task });
             task.workerSelection = routedWorker.selection;
             task.adapter = routedWorker.candidate.adapter;
             task.routing = routedModel.routing;

package/dist/reconciler-runtime.js

@@ -1,4 +1,5 @@
 import { transitionJobEvent, transitionTaskEvent } from './scheduler.js';
+import { DurableTaskTransitionRuntime } from './workflow/durable-transition.js';
 import { StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { WorkflowEffectExecutor } from './workflow/effects.js';
@@ -24,11 +25,13 @@ export class ReconcilerRuntimeBase {
     continuationLive = new Set();
     launchFailureClaims = new Set();
     terminalWaiters = new Map();
+    taskTransitions;
     workflowEffects = new WorkflowEffectExecutor();
     reconciling = false;
     constructor(store, options) {
         this.store = store;
         this.options = options;
+        this.taskTransitions = new DurableTaskTransitionRuntime(store);
     }
     async applyJobEffectOutcomes(job, outcomes) {
         for (const outcome of outcomes.filter(item => item.status === 'failed')) {
@@ -158,32 +161,28 @@ export class ReconcilerRuntimeBase {
         const live = this.live.get(event.task_id);
         if (live && event.job_id === live.jobId && event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
             return;
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
-            return;
-        const claimedExecution = task.state === 'QUEUED' && task.executionId !== null && task.leaseOwner !== null;
-        const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
-        if ((exactLiveExecution || claimedExecution) && task.state === 'QUEUED') {
-            await transitionTaskEvent(task, 'task.started');
-            task.failureReason = undefined;
-            task.error = null;
-            task.updatedAt = event.timestamp || new Date().toISOString();
-            await this.store.saveTask(task);
-            if (live)
-                live.workerStarted = true;
-            return;
-        }
-        if (task.state !== 'FAILED' || !this.isRecoverableWatchdogFailure(task))
-            return;
-        if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
+        const transition = await this.taskTransitions.apply(event.job_id, event.task_id, 'task.started', {
+            eligible: (job, task) => {
+                if (!task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
+                    return false;
+                const claimedExecution = task.executionId !== null && task.leaseOwner !== null;
+                const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
+                return Boolean(exactLiveExecution || claimedExecution || this.isRecoverableWatchdogFailure(task));
+            },
+            facts: (_job, task) => ({
+                recoverableExecution: this.isRecoverableWatchdogFailure(task)
+                    && (!event.timestamp || new Date(event.timestamp).getTime() >= new Date(task.updatedAt).getTime()),
+            }),
+            mutate: (_job, task) => {
+                task.updatedAt = event.timestamp || new Date().toISOString();
+            },
+        });
+        if (!transition?.decision.accepted)
             return;
-        await transitionTaskEvent(task, 'reconcile.started');
-        task.failureReason = undefined;
-        task.error = null;
-        task.updatedAt = event.timestamp || new Date().toISOString();
-        await this.store.saveTask(task);
-        this.detach(this.reconcile(job.id), job.id, task.id, 'late worker-start reconciliation');
+        if (live?.executionId === transition.task.executionId)
+            live.workerStarted = true;
+        if (transition.from === 'FAILED')
+            this.detach(this.reconcile(event.job_id), event.job_id, event.task_id, 'late worker-start reconciliation');
     }
     isRecoverableWatchdogFailure(task) {
         if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event', 'worker_delivery_after_start'].includes(task.failureReason ?? ''))
@@ -205,23 +204,25 @@ export class ReconcilerRuntimeBase {
         this.launchFailureClaims.add(claim);
         const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
         cleanup.unref();
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state))
+        const workflowEvent = phase === 'start-ack' ? 'worker.start_ack_failed' : 'worker.delivery_failed';
+        const transition = await this.taskTransitions.apply(jobId, taskId, workflowEvent, {
+            eligible: (_job, task) => task.executionId === executionId,
+            mutate: (_job, task) => {
+                this.clearExecution(task.id, executionId);
+                task.error = `Worker ${phase} failed: ${message}`;
+                task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+            },
+        });
+        if (!transition)
             return;
-        if (task.state === 'RUNNING') {
-            await this.emit(eventFor(jobId, taskId, task.parentTaskId, 'task.process.delivery_failed', 'failed', `Worker ${phase} reported after task.started: ${message}`, 'orchestrator', { phase, authoritative: false, executionId }, { agent: 'relay', component: 'agents-relay' }));
+        if (!transition.decision.accepted) {
+            await this.emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.process.delivery_failed', 'failed', `Worker ${phase} reported after lifecycle moved to ${transition.from}: ${message}`, 'orchestrator', { phase, authoritative: false, executionId, workflowEvent }, { agent: 'relay', component: 'agents-relay' }));
             return;
         }
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Worker ${phase} failed: ${message}`, 'user', { phase, reason: phase === 'start-ack' ? 'worker_start_timeout' : undefined }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        this.clearExecution(task.id, executionId);
-        task.error = event.message;
-        task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        await transitionTaskEvent(task, 'fail');
-        await this.store.saveTask(task);
-        await this.emit(event);
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: transition.task.failureReason, workflowEvent }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.detach(this.emit(event), jobId, taskId, 'worker failure event');
     }
     async runtimeSettled(jobId, taskId, executionId, result, error) {
         const live = this.live.get(taskId);
@@ -234,7 +235,7 @@ export class ReconcilerRuntimeBase {
         if (!task || task.executionId !== executionId)
             return;
         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 (['QUEUED', 'RUNNING'].includes(task.state) && task.adapter === 'codex' && !terminalExecutionClaimed(jobId, taskId, executionId))
+        if (task.adapter === 'codex' && !terminalExecutionClaimed(jobId, taskId, executionId))
             this.scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted === true);
     }
     scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted) {
@@ -248,28 +249,24 @@ export class ReconcilerRuntimeBase {
     async failUnexpectedExit(jobId, taskId, executionId, workerStarted) {
         if (terminalExecutionClaimed(jobId, taskId, executionId))
             return;
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state) || terminalExecutionClaimed(jobId, taskId, executionId))
-            return;
         const reason = workerStarted ? 'worker_exit_without_terminal_event' : 'worker_exit_before_start';
         const message = workerStarted
             ? `Worker ${taskId} exited after task.started without publishing a terminal task event`
             : `Worker ${taskId} exited before publishing task.started`;
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000 }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        if (task.state === 'QUEUED') {
-            this.clearExecution(task.id, executionId);
-            task.error = message;
-            task.failureReason = reason;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
+        const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
+            eligible: (_job, task) => task.executionId === executionId && !terminalExecutionClaimed(jobId, taskId, executionId),
+            mutate: (_job, task) => {
+                this.clearExecution(task.id, executionId);
+                task.error = message;
+                task.failureReason = reason;
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+            },
+        });
+        if (!transition?.decision.accepted)
+            return;
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000, workflowEvent: 'watchdog.failed' }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.detach(this.emit(event), jobId, taskId, 'watchdog failure event');
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);
@@ -277,81 +274,74 @@ export class ReconcilerRuntimeBase {
             live.controller.abort();
             live.execution.cancel();
         }
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state)) {
+        const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
+            eligible: (_job, task) => task.executionId === executionId,
+            mutate: (_job, task) => {
+                this.clearExecution(task.id, executionId);
+                task.error = `Task ${taskId} timed out waiting for the mandatory terminal worker event`;
+                task.failureReason = 'terminal_event_timeout';
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+            },
+        });
+        if (!transition?.decision.accepted) {
             this.clearExecution(taskId, executionId);
             return;
         }
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Task ${taskId} timed out waiting for the mandatory terminal worker event`, 'user', { reason: 'terminal_event_timeout', timeoutMs: task.timeoutMs });
-        if (task.state === 'QUEUED') {
-            task.error = event.message;
-            task.failureReason = 'terminal_event_timeout';
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-            this.clearExecution(task.id, executionId);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Task ${taskId} timed out waiting for the mandatory terminal worker event`, 'user', { reason: 'terminal_event_timeout', timeoutMs: transition.task.timeoutMs, workflowEvent: 'watchdog.failed' }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        this.detach(this.emit(event), jobId, taskId, 'timeout failure event');
     }
     async applyTerminalEvent(event, trustedInternal = false) {
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
-            return;
-        const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
-        if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
-            return;
-        if (task.state === 'FAILED' && this.isRecoverableWatchdogFailure(task) && (trustedInternal || !modelBacked || this.isCorrelatedWorkerEvent(task, event))) {
-            if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
-                return;
-            await transitionTaskEvent(task, 'reconcile.started');
-            task.failureReason = undefined;
-            task.error = null;
-        }
-        if (task.state !== 'RUNNING')
-            return;
-        const terminalWaiter = this.terminalWaiters.get(task.id);
-        if (terminalWaiter && (!event.timestamp || new Date(event.timestamp).getTime() < terminalWaiter.launchBarrier))
+        const transition = await this.taskTransitions.apply(event.job_id, event.task_id, event.type, {
+            eligible: (_job, task) => {
+                if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
+                    return false;
+                const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
+                if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
+                    return false;
+                const terminalWaiter = this.terminalWaiters.get(task.id);
+                return !terminalWaiter || Boolean(event.timestamp && new Date(event.timestamp).getTime() >= terminalWaiter.launchBarrier);
+            },
+            facts: (_job, task) => {
+                const processExitedAfterPublishedTerminal = task.failureReason === 'worker_exit_without_terminal_event';
+                const freshEnough = processExitedAfterPublishedTerminal
+                    || !event.timestamp
+                    || new Date(event.timestamp).getTime() >= new Date(task.updatedAt).getTime();
+                return { recoverableExecution: this.isRecoverableWatchdogFailure(task) && freshEnough };
+            },
+            mutate: (job, task) => {
+                const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
+                const acceptedExecutionId = task.executionId;
+                if (modelBacked && acceptedExecutionId)
+                    claimTerminalExecution(executionEventSource(job.id, task.id, acceptedExecutionId));
+                this.clearExecution(task.id, acceptedExecutionId);
+                task.leaseOwner = null;
+                task.leaseExpiresAt = null;
+                task.updatedAt = event.timestamp || new Date().toISOString();
+                this.terminalWaiters.get(task.id)?.resolve();
+                this.terminalWaiters.delete(task.id);
+                if (event.type === 'task.completed') {
+                    task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
+                    task.error = null;
+                    task.failureReason = undefined;
+                }
+                else if (event.type === 'task.failed') {
+                    task.error = event.message || `Task ${task.id} failed`;
+                    task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
+                }
+                else if (event.type === 'task.blocked') {
+                    task.error = event.message || `Task ${task.id} blocked`;
+                }
+                else if (event.type === 'task.cancelled') {
+                    task.error = event.message || `Task ${task.id} cancelled`;
+                }
+            },
+        });
+        if (!transition?.decision.accepted)
             return;
-        const acceptedExecutionId = task.executionId;
-        if (modelBacked && acceptedExecutionId)
-            claimTerminalExecution(executionEventSource(job.id, task.id, acceptedExecutionId));
-        this.clearExecution(task.id, acceptedExecutionId);
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.updatedAt = event.timestamp || new Date().toISOString();
-        this.terminalWaiters.get(task.id)?.resolve();
-        this.terminalWaiters.delete(task.id);
-        if (event.type === 'task.completed') {
-            task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
-            task.error = null;
-            task.failureReason = undefined;
-            await transitionTaskEvent(task, 'task.completed');
-            await this.store.saveTask(task);
-            await this.deliverContinuation(job, task);
-        }
-        else if (event.type === 'task.failed') {
-            task.error = event.message || `Task ${task.id} failed`;
-            task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
-            await transitionTaskEvent(task, 'task.failed');
-            await this.store.saveTask(task);
-        }
-        else if (event.type === 'task.blocked') {
-            task.error = event.message || `Task ${task.id} blocked`;
-            await transitionTaskEvent(task, 'task.blocked');
-            await this.store.saveTask(task);
-        }
-        else if (event.type === 'task.cancelled') {
-            task.error = event.message || `Task ${task.id} cancelled`;
-            await transitionTaskEvent(task, 'task.cancelled');
-            await this.store.saveTask(task);
-        }
-        this.detach(this.reconcile(job.id), job.id, task.id, 'terminal-event reconciliation');
+        if (event.type === 'task.completed')
+            await this.deliverContinuation(transition.job, transition.task);
+        this.detach(this.reconcile(transition.job.id), transition.job.id, transition.task.id, 'terminal-event reconciliation');
     }
     terminalWait(taskId, executionId, launchBarrier) {
         let resolve;

package/dist/reconciler.js

@@ -6,11 +6,12 @@ import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
 import { agentContractPrompt, executionContextPrompt, resolveExecutionContext } from './execution-context.js';
-import { agentGraphPrompt } from './agent-graph.js';
+import { agentGraphPrompt, validateAgentSelection } from './agent-graph.js';
 import { ReconcilerReviewBase } from './reconciler-review.js';
 import { executionEventSource } from './reconciler-runtime.js';
 export { executionEventSource } from './reconciler-runtime.js';
 import { CallbackWorkflowEffectHandler } from './workflow/effects.js';
+import { applyHistoricalJobCompatibilityRepair } from './workflow/runtime.js';
 import { pendingTroubleshooterTasks } from './troubleshooter.js';
 import { prepareManagedExecutionWorktree } from './workspace.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
@@ -114,8 +115,7 @@ export class Reconciler extends ReconcilerReviewBase {
                 if (job.state !== terminalState) {
                     if (!['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'].includes(job.state)) {
                         // Compatibility repair boundary for historical records that persisted runtime status as lifecycle.
-                        job.state = terminalState;
-                        job.updatedAt = new Date().toISOString();
+                        applyHistoricalJobCompatibilityRepair(job, terminalState);
                         await this.store.saveJob(job);
                         const outcomes = await this.workflowEffects.execute(['effect.cancelActiveTasks'], { jobId: job.id, transitionKey: `compatibility:${prState}`, data: { reason } });
                         await this.applyJobEffectOutcomes(job, outcomes);
@@ -289,8 +289,12 @@ export class Reconciler extends ReconcilerReviewBase {
         return this.store.load(job.id);
     }
     async recoverPlannerChildren(job) {
+        const contextTask = job.tasks.find(task => task.kind === 'planner') ?? job.tasks[0];
+        if (!contextTask)
+            return;
+        const executionContext = await this.resolvedContext(job, contextTask, 'planner');
         for (const planner of job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult)) {
-            const children = planner.plannerResult?.next_tasks.map(spec => this.plannerChild(job, planner, spec)) ?? [];
+            const children = planner.plannerResult?.next_tasks.map(spec => this.plannerChild(job, planner, spec, executionContext)) ?? [];
             for (const child of children) {
                 const existing = job.tasks.find(item => item.id === child.id);
                 if (existing) {
@@ -475,7 +479,8 @@ export class Reconciler extends ReconcilerReviewBase {
         }
         try {
             const result = parsePlannerResult(raw);
-            const children = result.next_tasks.map(spec => this.plannerChild(job, task, spec));
+            const executionContext = await this.resolvedContext(job, task, 'planner');
+            const children = result.next_tasks.map(spec => this.plannerChild(job, task, spec, executionContext));
             for (const child of children) {
                 const existing = job.tasks.find(item => item.id === child.id);
                 if (!existing)
@@ -516,7 +521,8 @@ export class Reconciler extends ReconcilerReviewBase {
         }
         this.detach(this.reconcile(jobId), jobId, task.id, 'planner follow-up reconciliation');
     }
-    plannerChild(job, planner, spec) {
+    plannerChild(job, planner, spec, executionContext) {
+        validateAgentSelection(executionContext, spec.agentName, spec.agentGraph);
         const now = new Date().toISOString();
         return { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, parentTaskId: planner.id, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, adapter: 'codex', input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, state: (spec.dependencies?.length ?? 0) > 0 ? 'DRAFT' : 'QUEUED', attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: planner.id, planningSource: planner.planningSource ?? 'model-planner', planningRound: planner.planningRound ?? 1 };
     }

package/dist/relayd.js

@@ -16,6 +16,7 @@ import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { decisionMode, LayaCliDecisionEngine } from './decision.js';
+import { JsonlDecisionAuditStore } from './decision-audit.js';
 export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
 
 Usage:
@@ -72,7 +73,8 @@ export async function runDaemon(argv) {
     const repositoryPaths = new Map(discoveredRepositories.map(item => [item.repository, item.path]));
     const explicitProjectPath = value(argv, '--project-path');
     const usageRegistry = codexAndZaiUsageRegistry();
-    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(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
+    const decisionAuditStore = new JsonlDecisionAuditStore(process.env.AGENTS_RELAY_DECISION_AUDIT_PATH ?? join(homedir(), '.agents-relay', 'decision-audit.jsonl'));
+    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(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
     const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler);

package/dist/routing-policy.js

@@ -0,0 +1,75 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const EMPTY_POLICY = {};
+function safePolicy(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const source = value;
+    const strings = (item) => Array.isArray(item) && item.every(value => typeof value === 'string') ? [...item] : undefined;
+    const result = {};
+    result.disabledProfiles = strings(source.disabledProfiles);
+    result.disabledProviders = strings(source.disabledProviders);
+    result.preferredProviders = strings(source.preferredProviders);
+    result.preferredProfiles = strings(source.preferredProfiles);
+    if (source.qualityByTaskKind && typeof source.qualityByTaskKind === 'object' && !Array.isArray(source.qualityByTaskKind)) {
+        result.qualityByTaskKind = {};
+        for (const [key, value] of Object.entries(source.qualityByTaskKind)) {
+            const parsed = strings(value);
+            if (parsed)
+                result.qualityByTaskKind[key] = parsed;
+        }
+    }
+    if (source.recovery && typeof source.recovery === 'object' && !Array.isArray(source.recovery)) {
+        const penalize = source.recovery.penalizePriorRoute;
+        if (typeof penalize === 'boolean')
+            result.recovery = { penalizePriorRoute: penalize };
+    }
+    return result;
+}
+export function policyPath(explicit) {
+    return explicit ?? process.env.AGENTS_RELAY_ROUTING_POLICY ?? join(process.cwd(), '.agents-relay-routing-policy.json');
+}
+export function modelRouterRulesPath(explicit) {
+    return explicit ?? process.env.AGENTS_RELAY_MODEL_ROUTER_RULES ?? join(process.cwd(), '.agents-relay-model-router-rules.md');
+}
+export async function loadModelRouterRules(explicit) {
+    const path = modelRouterRulesPath(explicit);
+    try {
+        const text = await readFile(path, 'utf8');
+        return { path, hash: createHash('sha256').update(text).digest('hex'), text };
+    }
+    catch {
+        return { path, hash: 'none', text: '' };
+    }
+}
+export async function saveModelRouterRules(text, explicit) {
+    const path = modelRouterRulesPath(explicit);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, text, 'utf8');
+    return { path, hash: createHash('sha256').update(text).digest('hex'), text };
+}
+export async function loadRoutingPolicy(explicit, explicitRules) {
+    const path = policyPath(explicit);
+    const rules = await loadModelRouterRules(explicitRules);
+    try {
+        const text = await readFile(path, 'utf8');
+        const policy = safePolicy(JSON.parse(text));
+        return { path, hash: createHash('sha256').update(text).digest('hex'), policy, snapshot: JSON.parse(JSON.stringify(policy)), rules };
+    }
+    catch {
+        return { path: null, hash: 'none', policy: EMPTY_POLICY, snapshot: {}, rules };
+    }
+}
+export function policyAllows(candidate, policy) {
+    if (policy.disabledProviders?.includes(candidate.provider))
+        return false;
+    if (candidate.profile && policy.disabledProfiles?.includes(candidate.profile))
+        return false;
+    return true;
+}
+export function policyRank(candidate, taskKind, policy) {
+    const preferred = new Set([...(policy.preferredProviders ?? []), ...(policy.preferredProfiles ?? [])]);
+    const quality = taskKind ? new Set(policy.qualityByTaskKind?.[taskKind] ?? []) : new Set();
+    return (preferred.has(candidate.provider) || (candidate.profile && preferred.has(candidate.profile)) ? 2 : 0) + (quality.has(candidate.id) ? 1 : 0);
+}

package/dist/runtime-status.js

@@ -46,6 +46,8 @@ export function deriveJobRuntimeStatus(job, prState = 'OPEN') {
         return 'FAILED';
     if (job.tasks.some(task => task.state === 'DRAFT'))
         return 'WAITING';
+    if (job.executionMode === 'autonomous' && job.autoMerge === false && job.reviewEnabled === false && implementationComplete(job) && prState === 'OPEN')
+        return 'WAITING';
     if (job.reviewEnabled === false && implementationComplete(job) && prState === 'OPEN')
         return 'MERGE_PENDING';
     return 'IDLE';

package/dist/scheduler.js

@@ -35,13 +35,19 @@ export function extendRetryBudget(task, windowSize = 3) {
     const usedOrBudgeted = Math.max(task.maxAttempts, task.attempt);
     return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
 }
-export async function transitionTaskEvent(task, event, context = {}) {
+export function tryTransitionTaskEvent(task, event, context = {}) {
     const decision = decideTaskLifecycle(task, event, context);
+    if (decision.accepted && decision.target)
+        applyTaskWorkflowDecision(task, decision);
+    return decision;
+}
+export async function transitionTaskEvent(task, event, context = {}) {
+    const from = task.state;
+    const decision = tryTransitionTaskEvent(task, event, context);
     if (!decision.accepted || !decision.target)
         throw new Error(decision.reason === 'ambiguous'
-            ? `Ambiguous workflow transition from ${task.state} on ${event}`
-            : `No enabled workflow transition from ${task.state} on ${event}`);
-    applyTaskWorkflowDecision(task, decision);
+            ? `Ambiguous workflow transition from ${from} on ${event}`
+            : `No enabled workflow transition from ${from} on ${event}`);
     return decision;
 }
 export async function transitionJobEvent(job, event, context = {}) {

package/dist/troubleshooter.js

@@ -24,7 +24,7 @@ Retrieve this task's lifecycle event history before classifying the root cause o
 GET http://127.0.0.1:8787/api/events?job=${encodeURIComponent(job.id)}&task=${encodeURIComponent(task.id)}&limit=200
 Inspect event order, type/status, source, data/phase, duplicate events, missing expected lifecycle events, late events, and execution identifiers. If the event stream points to delivery/runtime failure, inspect the corresponding Relay/worker/tool logs too. Do not treat the final task.error string as the complete root cause.
 
-Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
+Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Only model/provider/runtime evidence may call the narrow model re-decision action; that action gathers fresh usage, reloads current policy, updates this exact Task's routing, and does not retry it. Troubleshooter must then reactivate/retry this exact original task and verify progress. Do not manually choose a provider/model or create a replacement task. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
 }
 function belongsToCurrentRun(job, task) {
     const slot = job.schedule?.currentRunSlot;

package/dist/workflow/contracts.js

@@ -12,9 +12,6 @@ export const WORKFLOW_EVENT_NAMES = [
     'pr.closed',
     'pr.merged',
     'reconcile',
-    'reconcile.blocked',
-    'reconcile.completed',
-    'reconcile.started',
     'release',
     'retry',
     'review.approved',
@@ -23,6 +20,9 @@ export const WORKFLOW_EVENT_NAMES = [
     'task.completed',
     'task.failed',
     'task.started',
+    'watchdog.failed',
+    'worker.delivery_failed',
+    'worker.start_ack_failed',
 ];
 export const WORKFLOW_FACT_NAMES = [
     'dependenciesSatisfied',
@@ -31,6 +31,7 @@ export const WORKFLOW_FACT_NAMES = [
     'dispatchable',
     'notMerged',
     'autoMerge',
+    'recoverableExecution',
 ];
 export const WORKFLOW_MUTATION_NAMES = [
     'mutation.clearError',

package/dist/workflow/definitions.js

@@ -33,4 +33,5 @@ export const taskLifecycleWorkflow = load('task-lifecycle', {
     dependenciesUnsatisfied: booleanGuard('dependenciesUnsatisfied'),
     runnable: booleanGuard('runnable'),
     dispatchable: booleanGuard('dispatchable'),
+    recoverableExecution: booleanGuard('recoverableExecution'),
 });

package/dist/workflow/durable-transition.js

@@ -0,0 +1,45 @@
+import { tryTransitionTaskEvent } from '../scheduler.js';
+/**
+ * Runtime primitive for applying one canonical Task-graph event to fresh durable state.
+ *
+ * This class owns serialization and persistence only. It does not decide lifecycle
+ * legality: the canonical Mermaid Task graph does that through tryTransitionTaskEvent.
+ */
+export class DurableTaskTransitionRuntime {
+    store;
+    locks = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    async apply(jobId, taskId, event, options = {}) {
+        return this.withLock(`${jobId}/${taskId}`, async () => {
+            const job = await this.store.load(jobId);
+            const task = job.tasks.find(item => item.id === taskId);
+            if (!task || (options.eligible && !options.eligible(job, task)))
+                return null;
+            const from = task.state;
+            const decision = tryTransitionTaskEvent(task, event, options.facts?.(job, task) ?? {});
+            if (!decision.accepted || !decision.target)
+                return { job, task, from, decision };
+            await options.mutate?.(job, task, decision);
+            await this.store.saveTask(task);
+            return { job, task, from, decision };
+        });
+    }
+    async withLock(key, work) {
+        const previous = this.locks.get(key);
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        this.locks.set(key, current);
+        if (previous)
+            await previous;
+        try {
+            return await work();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === current)
+                this.locks.delete(key);
+        }
+    }
+}

package/dist/workflow/runtime.js

@@ -37,3 +37,10 @@ export function applyJobWorkflowDecision(job, decision, timestamp = new Date().t
     job.state = decision.target;
     job.updatedAt = timestamp;
 }
+/** Historical repair for records that stored derived runtime status as Job lifecycle. */
+export function applyHistoricalJobCompatibilityRepair(job, target, timestamp = new Date().toISOString()) {
+    if (target !== 'COMPLETED' && target !== 'CANCELLED')
+        throw new Error(`Invalid historical Job repair target ${target}`);
+    job.state = target;
+    job.updatedAt = timestamp;
+}

package/package.json

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

package/skills/agents-relay/agents/implementation.agent.md

@@ -0,0 +1,24 @@
+---
+name: implementation
+description: Implement the assigned Agents Relay task in the managed checkout and verify the durable result.
+capabilities: [implementation, local_repo, iterative_tools]
+runtime: codex
+delegation: [relay-child-task]
+restrictions: [preserve-user-changes, no-unrelated-refactors]
+---
+
+# Implementation Agent
+
+Implement the assigned Task in the current managed checkout. Treat the durable
+Job objective and Task input retrieved from GitHub as authoritative. Inspect the
+existing design before editing, keep the change narrowly scoped, and preserve
+unrelated user work.
+
+Follow the shared Agents Relay and events-bus contracts. Publish the required
+canonical `task.started` event before doing work, then exactly one terminal task
+event after the declared output is durable. Use the exact execution source
+identity supplied by Relay for every lifecycle event.
+
+Run the most relevant tests and checks for the change. Do not claim completion
+without durable implementation evidence, validation results, and a concise
+summary of changed files and remaining risks.

package/skills/agents-relay/agents/planner.agent.md

@@ -58,6 +58,8 @@ Do not create separate Tasks merely for "analyze", "format", "call tool", "check
 ## Rules
 
 - Treat durable Job/Task state as authoritative.
+- Discover visible agents from the resolved execution context before selecting an agent. Choose an existing visible agent only when it is appropriate for the Task; otherwise leave `agentName` unset. Agent discovery is runtime/context-specific, not a hardcoded global list.
+- Build `agentGraph` nodes only from agents in the discovered visible-agent catalog. Every named graph agent must be visible in the resolved planning/execution context.
 - Never invent completed work or evidence.
 - First decide whether the objective is already satisfied.
 - If satisfied, return `objective_status: "satisfied"` and `next_tasks: []`.

package/workflow/task-lifecycle.mmd

@@ -14,20 +14,26 @@ stateDiagram-v2
     QUEUED --> BLOCKED: block
     QUEUED --> FAILED: fail
     QUEUED --> FAILED: effect.launchTask.failed
+    QUEUED --> FAILED: watchdog.failed
+    QUEUED --> FAILED: worker.delivery_failed
+    QUEUED --> FAILED: worker.start_ack_failed
     QUEUED --> CANCELLED: cancel
 
     RUNNING --> BLOCKED: task.blocked
     RUNNING --> SUCCEEDED: task.completed / mutation.clearError,mutation.clearFailureReason
     RUNNING --> FAILED: task.failed
+    RUNNING --> FAILED: watchdog.failed
     RUNNING --> CANCELLED: task.cancelled
 
     BLOCKED --> QUEUED: retry / mutation.clearError,mutation.clearFailureReason
     BLOCKED --> CANCELLED: cancel
 
     FAILED --> QUEUED: retry / mutation.clearError,mutation.clearFailureReason
-    FAILED --> RUNNING: reconcile.started / mutation.clearError,mutation.clearFailureReason
-    FAILED --> SUCCEEDED: reconcile.completed / mutation.clearError,mutation.clearFailureReason
-    FAILED --> BLOCKED: reconcile.blocked
+    FAILED --> RUNNING: task.started [recoverableExecution] / mutation.clearError,mutation.clearFailureReason
+    FAILED --> SUCCEEDED: task.completed [recoverableExecution] / mutation.clearError,mutation.clearFailureReason
+    FAILED --> BLOCKED: task.blocked [recoverableExecution]
+    FAILED --> FAILED: task.failed [recoverableExecution]
+    FAILED --> CANCELLED: task.cancelled [recoverableExecution]
     FAILED --> CANCELLED: cancel
 
     SUCCEEDED --> [*]