agents-relay 1.0.103 → 1.0.105

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

@@ -109,12 +109,25 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const registered = await this.store.listAgents();
         const candidates = workerCandidates(this.options.adapters, registered, usage);
         for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
-            const requirements = task.workerRequirements ?? { capabilities: task.capabilities.length > 0 ? task.capabilities : ['model'] };
-            const taskFacts = { id: task.id, kind: task.kind ?? 'work', storySize: task.storySize ?? 'M', capabilities: task.capabilities };
-            const routedWorker = await routeWorker(candidates, requirements, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts });
+            const requirements = task.workerRequirements ?? { capabilities: [] };
+            const taskFacts = {
+                id: task.id,
+                kind: task.kind ?? 'work',
+                storySize: task.storySize ?? 'M',
+                agentName: task.agentName ?? null,
+                input: task.input,
+                attachments: task.attachments ?? [],
+                output: task.output ?? null,
+            };
+            const routedWorker = await routeWorker(candidates, requirements, {
+                decisionEngine: this.options.decisionEngine,
+                decisionMode: this.options.decisionMode,
+                taskFacts,
+                usage,
+            });
             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;