agents-relay 2.0.141 → 2.0.143

package/dist/cli-workflow-action.js

@@ -0,0 +1,15 @@
+/** Graph-authorized public CLI action IDs delegate to canonical Task commands. */
+export async function runWorkflowAction(args, execute) {
+    const value = (flag) => { const i = args.indexOf(flag); return i < 0 ? '' : args[i + 1] ?? ''; };
+    const actions = {
+        'task.retry': 'retry', 'task.recover': 'recover', 'task.cancel': 'cancel',
+        'task.unblock': 'unblock', 'task.escalate': 'escalate',
+        'task.resume-troubleshooter': 'resume-troubleshooter',
+    };
+    const operation = actions[value('--action')];
+    if (!operation)
+        throw Error('workflow action requires a supported Graph-authorized task Action ID');
+    if (!value('--repo') || !value('--id') || !value('--task-id'))
+        throw Error('workflow action requires --repo, --id and --task-id');
+    await execute(operation);
+}

package/dist/cli-workflow.js

@@ -0,0 +1,88 @@
+/** Read-only workflow discovery/evaluation; executable effects require durable authorization. */
+import { buildWorkflowUsageIndex, defaultWorkflowDirectory, executableGraphs, whereWorkflowSymbol } from './workflow/usage-index.js';
+import { ConditionRegistry, booleanCondition } from './workflow/conditions.js';
+import { GraphRuntime } from './workflow/graph-v2.js';
+import { dispatchWorkflowGraphSync } from './workflow/dispatcher.js';
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync } from 'node:fs';
+import { verifyAuthoritativeCondition } from './workflow/authoritative-conditions.js';
+import { WORKFLOW_EVENT_NAMES, WORKFLOW_EFFECT_NAMES, WORKFLOW_MUTATION_NAMES } from './workflow/contracts.js';
+export function workflowCliResult(args) {
+    const [verb, ...options] = args;
+    const value = (flag) => {
+        const offset = options.indexOf(flag);
+        return offset >= 0 ? options[offset + 1] ?? '' : '';
+    };
+    const graphs = executableGraphs(defaultWorkflowDirectory());
+    const index = buildWorkflowUsageIndex(graphs);
+    if (verb === 'discover')
+        return { graphs: [...graphs.keys()], symbols: [...new Set(index.map(x => x.id))].sort() };
+    if (verb === 'where')
+        return whereWorkflowSymbol(index, value('--id'));
+    if (verb === 'inspect') {
+        const name = value('--graph');
+        const graph = graphs.get(name);
+        if (!graph)
+            throw new Error('unknown executable graph');
+        return { graph: name, initial: graph.initial, nodes: [...graph.nodes.values()], edges: graph.edges };
+    }
+    if (verb === 'evaluate') {
+        const name = value('--graph');
+        const graph = graphs.get(name);
+        if (!graph)
+            throw new Error('unknown executable graph');
+        const inputId = value('--event');
+        const state = value('--state');
+        if (!inputId || !state)
+            throw new Error('evaluate requires --event and --state');
+        const evidence = value('--facts');
+        const facts = evidence ? JSON.parse(evidence) : {};
+        if (!facts || typeof facts !== 'object' || Array.isArray(facts))
+            throw new Error('facts must be a JSON object');
+        const record = facts;
+        const guards = [...new Set([...graph.nodes.values()].filter(n => n.kind === 'guard').map(n => n.semanticId))];
+        const conditions = new ConditionRegistry(guards.map(booleanCondition));
+        const runtime = new GraphRuntime(graph, {
+            states: new Set([...graph.nodes.values()].filter(n => n.kind === 'state').map(n => n.semanticId)),
+            guards: Object.fromEntries(guards.map(id => [id, conditions.guard(id)])),
+            actions: Object.fromEntries([...new Set([...WORKFLOW_EFFECT_NAMES, ...WORKFLOW_MUTATION_NAMES, ...[...graph.nodes.values()].filter(n => n.kind === 'action').map(n => n.semanticId)])].map(id => [id, { id }])),
+            events: Object.fromEntries([...new Set([...WORKFLOW_EVENT_NAMES, inputId, ...graph.edges.filter(e => e.kind === 'on' || e.kind === 'emit').map(e => e.semanticId).filter((id) => !!id)])].map(id => [id, { id }])),
+        });
+        return { mode: 'dry-run', decision: dispatchWorkflowGraphSync(runtime, { initialState: state, input: { transport: 'event', id: inputId, payload: {} }, durableFacts: record }) };
+    }
+    if (verb === 'verify') {
+        const path = value('--sqlite');
+        const jobId = value('--job');
+        const predicate = value('--condition');
+        const allowed = new Set(['task.queued', 'task.succeeded', 'task.failed', 'task.routing-cleared', 'task.execution-stopped', 'job.objective-verified', 'job.completed']);
+        if (!path || !existsSync(path) || !jobId || !allowed.has(predicate))
+            throw new Error('verify requires existing --sqlite, --job and supported --condition');
+        const db = new DatabaseSync(path, { readOnly: true });
+        try {
+            return { condition: predicate, jobId, taskId: value('--task') || null, outcome: verifyAuthoritativeCondition(db, jobId, predicate, value('--task'), value('--execution')) };
+        }
+        finally {
+            db.close();
+        }
+    }
+    if (verb === 'trace') {
+        const path = value('--sqlite');
+        const key = value('--attempt-key');
+        if (!path || !key || !existsSync(path))
+            throw new Error('trace requires existing --sqlite path and --attempt-key');
+        const db = new DatabaseSync(path, { readOnly: true });
+        try {
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workflow_action_trace'").get();
+            if (!table)
+                return { attemptKey: key, trace: null };
+            const record = db.prepare('SELECT attempt_key,execution_id,generation,graph,action_id,condition_id,outcome,observed_at FROM workflow_action_trace WHERE attempt_key=?').get(key) ?? null;
+            return { attemptKey: key, trace: record };
+        }
+        finally {
+            db.close();
+        }
+    }
+    if (verb === 'action')
+        throw new Error('durable graph authorization required; unsafe action request refused');
+    throw new Error('workflow supports discover, inspect, where, evaluate; action/trace require durable authorization');
+}

package/dist/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { runWorkflowAction } from './cli-workflow-action.js';
+import { workflowCliResult } from './cli-workflow.js';
 import { configureLocalGitMerge } from './cli-local-merge-config.js';
 import { noGitHubMode } from './no-github.js';
 import { discoverLocalRelayStoreSnapshots, relayStoreDirectory } from './relay-store.js';
@@ -712,6 +714,14 @@ async function main() {
         });
         return;
     }
+    if (command === 'workflow') {
+        if (args[0] === 'action') {
+            await runWorkflowAction(args, operation => runTaskCommand(operation, args));
+            return;
+        }
+        console.log(JSON.stringify(workflowCliResult(args), null, 2));
+        return;
+    }
     if (command === 'job') {
         const [action, ...jobArgs] = args;
         await runJobCommand(action ?? '', jobArgs);

package/dist/dashboard-html.js

@@ -294,7 +294,7 @@ function githubUsageCard(effective,status){
 }
 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:[];const grid=element('div','usage-providers');if(overview.githubEffective||overview.githubStatus)grid.append(githubUsageCard(overview.githubEffective,overview.githubStatus));for(const provider of providers)grid.append(usageProvider(provider));for(const provider of credits)grid.append(creditProvider(provider));if(!grid.children.length){usageRoot.append(element('p','empty',text('Usage telemetry is unavailable.')));return;}usageRoot.append(grid);}catch(error){usageMeta.textContent='Unavailable';usageRoot.replaceChildren(element('p','error-state',text('Usage unavailable: '+error.message)));}}
 function selectedWorkflowGraph(){return workflowGraphs.find(graph=>graph.id===selectedGraphId)||null;}
-function graphLinks(source){const links=new Map();for(const line of source.split('\\n')){const match=/^\\s*click\\s+([A-Za-z0-9_]+)\\s+href\\s+"([a-z0-9-]+\\.mmd)"\\s*$/.exec(line);if(!match)continue;const id=match[2].slice(0,-4);if(workflowGraphs.some(graph=>graph.id===id))links.set(match[1],id);}return links;}
+function graphLinks(source){const links=new Map();for(const line of source.split('\\n')){const match=/^\\s*click\\s+([A-Za-z0-9_]+)\\s+href\\s+"([a-z0-9-]+\\.mmd)"(?:\\s+"[^"\\n]*")?\\s*$/.exec(line);if(!match)continue;const id=match[2].slice(0,-4);if(workflowGraphs.some(graph=>graph.id===id))links.set(match[1],id);}return links;}
 function graphTargets(id){const graph=selectedWorkflowGraph();return graph?[...new Set(graphLinks(graph.source).values())]:[];}
 function graphFromHash(){if(location.hash==='#/graphs'||location.hash==='#/graphs/entry')return 'main';if(!location.hash.startsWith('#/graphs/'))return null;const id=location.hash.slice(9);return /^[a-z0-9-]+$/.test(id)?id:null;}
 const WORKFLOW_NAV_KEY='agents-relay:workflow-navigation';
@@ -308,11 +308,11 @@ function renderGraphNavigation(){const graph=selectedWorkflowGraph();initializeG
 function renderGraphList(){graphList.replaceChildren();if(!workflowGraphs.length){graphList.append(element('p','empty',text('No workflow graphs found.')));return;}for(const graph of workflowGraphs){const button=document.createElement('button');button.type='button';button.className='graph-button';button.setAttribute('aria-current',String(graph.id===selectedGraphId));button.append(element('strong','',text(graph.name)),element('span','',text(graph.path)));button.addEventListener('click',()=>navigateGraph(graph.id));graphList.append(button);}}
 async function graphDetail(kind,name){const panel=document.querySelector('#graph-detail');panel.hidden=false;panel.replaceChildren(element('strong','',text(kind+': '+name)),element('p','subtle',text('Loading authoritative references…')));try{const params=new URLSearchParams({graph:selectedGraphId,kind,name});const result=await loadJSON('/api/graph-symbol?'+params);panel.replaceChildren(element('strong','',text(kind+': '+name)));const sections=[['Graph',[result.graph]],['Canonical contract',result.contracts],['Implementation',result.implementation],['Tests',result.tests]];for(const [heading,refs] of sections){panel.append(element('p','detail-label',text(heading)));if(!refs?.length){panel.append(element('p','subtle',text('No exact symbol reference found.')));continue;}for(const ref of refs){const link=element('a','',text(ref.path+(ref.line>0?':'+ref.line:'')+' ['+(ref.evidence==='exact-token'?'verified graph token':'text-search suggestion')+']'));if(WORKFLOW_SOURCE_REF){link.href='https://github.com/lalalic/agents-relay/blob/'+WORKFLOW_SOURCE_REF+'/'+ref.path+(ref.line>0?'#L'+ref.line:'');link.target='_blank';link.rel='noopener noreferrer';}else{link.removeAttribute('href');link.title='Source revision unavailable';}link.target='_blank';link.rel='noopener noreferrer';panel.append(link,document.createTextNode('  '));}}panel.scrollIntoView({block:'nearest'});}catch(error){panel.append(element('p','error-state',text('Reference lookup unavailable: '+error.message)));}}
 function interactiveNode(node,callback,label){node.classList.add('drillable');node.setAttribute('tabindex','0');node.setAttribute('role','button');node.setAttribute('aria-label',label);node.addEventListener('click',callback);node.addEventListener('keydown',event=>{if(event.key==='Enter'||event.key===' '){event.preventDefault();callback();}});}
-function graphNodeDefinitions(source){const result=new Map();for(const line of source.split('\\n')){const pattern=/([A-Za-z0-9_]+)\\["([^"\\n]+)"\\]/g;for(const match of line.matchAll(pattern))result.set(match[1],match[2]);}return result;}
+function graphNodeDefinitions(source){const result=new Map();for(const line of source.split('\\n')){const pattern=/([A-Za-z0-9_]+)(?:\\["([^"\\n]+)"\\]|\\{"([^"\\n]+)"\\})/g;for(const match of line.matchAll(pattern))result.set(match[1],match[2]||match[3]);}return result;}
 function addNodeLabel(node,label){const ns='http://www.w3.org/2000/svg';const old=node.querySelector('g.label');if(old)old.remove();const textNode=document.createElementNS(ns,'text');textNode.setAttribute('x','0');textNode.setAttribute('y','0');textNode.setAttribute('text-anchor','middle');textNode.setAttribute('dominant-baseline','middle');textNode.setAttribute('fill','#182536');textNode.setAttribute('font-size','13');const rect=node.querySelector('rect.label-container,rect.basic,rect');const width=Math.max(65,Number(rect?.getAttribute('width')||135)-14);const maxChars=Math.max(9,Math.floor(width/7.2));const words=label.split(/\\s+/);const lines=[];let current='';for(const word of words){if(current&&(current+' '+word).length>maxChars){lines.push(current);current=word;}else current=current?current+' '+word:word;}if(current)lines.push(current);for(let i=0;i<lines.length;i++){const tspan=document.createElementNS(ns,'tspan');tspan.setAttribute('x','0');tspan.setAttribute('dy',i===0?String(-((lines.length-1)*7)):'14');tspan.textContent=lines[i];textNode.append(tspan);}node.append(textNode);}
-function sanitizeGraphSvg(markup){const parsed=new DOMParser().parseFromString(markup,'image/svg+xml');const source=parsed.documentElement;if(source.localName!=='svg'||parsed.querySelector('parsererror'))throw new Error('Invalid SVG');const ns='http://www.w3.org/2000/svg';const elements=new Set(['svg','g','path','rect','circle','ellipse','line','polyline','polygon','text','tspan','defs','marker','title','desc','clipPath']);const attributes=new Set(['id','class','viewBox','width','height','x','y','x1','y1','x2','y2','cx','cy','r','rx','ry','d','points','transform','fill','stroke','stroke-width','stroke-dasharray','stroke-linecap','stroke-linejoin','opacity','fill-opacity','stroke-opacity','font-size','font-family','font-weight','text-anchor','dominant-baseline','markerWidth','markerHeight','markerUnits','refX','refY','orient','preserveAspectRatio','clip-path','marker-start','marker-mid','marker-end','role','aria-label']);const clean=node=>{if(node.nodeType===3)return document.createTextNode(node.textContent||'');if(node.nodeType!==1||node.namespaceURI!==ns||!elements.has(node.localName))return null;const out=document.createElementNS(ns,node.localName);for(const attr of node.attributes){if(!attr.namespaceURI&&attr.name==='style'){for(const declaration of attr.value.split(';')){const split=declaration.indexOf(':');if(split<0)continue;const property=declaration.slice(0,split).trim();const cssValue=declaration.slice(split+1).trim();if((property==='stroke'||property==='fill')&&/^(?:#[0-9a-fA-F]{3,8}|rgb\\([0-9.,%\\s]+\\)|none|currentColor)$/.test(cssValue))out.setAttribute(property,cssValue);else if(property==='stroke-width'&&/^[0-9]+(?:\\.[0-9]+)?(?:px)?$/.test(cssValue))out.setAttribute(property,cssValue);}continue;}if(attr.namespaceURI||!attributes.has(attr.name))continue;if(['marker-start','marker-mid','marker-end','clip-path'].includes(attr.name)){if(!attr.value.startsWith('url(#')||!attr.value.endsWith(')')||!(/^[a-zA-Z0-9_-]+$/.test(attr.value.slice(5,-1))))continue;}else if(attr.value.toLowerCase().includes('url(')||attr.value.includes('<')||attr.value.includes('>'))continue;out.setAttribute(attr.name,attr.value);}for(const child of node.childNodes){const safe=clean(child);if(safe)out.appendChild(safe);}return out;};return clean(source);}
-function applyGraphPalette(svg){const ns='http://www.w3.org/2000/svg';for(const path of svg.querySelectorAll('path')){if(path.closest('marker')){if(!path.hasAttribute('fill'))path.setAttribute('fill','#65768a');continue;}if(!path.hasAttribute('fill'))path.setAttribute('fill','none');if(!path.hasAttribute('stroke'))path.setAttribute('stroke','#65768a');}for(const node of svg.querySelectorAll('g.node')){const error=node.classList.contains('failure');for(const shape of node.querySelectorAll('rect,polygon,circle,ellipse')){shape.setAttribute('fill',error?'#ffe4e4':'#f9fbff');shape.setAttribute('stroke',error?'#be3030':'#657f9e');shape.setAttribute('stroke-width','1.3');}for(const label of node.querySelectorAll('text'))label.setAttribute('fill',error?'#7c1818':'#182536');}for(const rect of svg.querySelectorAll('rect')){if(!rect.closest('g.node')&&!rect.hasAttribute('fill'))rect.setAttribute('fill','#ffffff');}for(const label of svg.querySelectorAll('text'))if(!label.hasAttribute('fill'))label.setAttribute('fill','#182536');}
-async function renderSelectedGraph(){const graph=selectedWorkflowGraph();renderGraphNavigation();document.querySelector('#graph-detail').hidden=true;if(!graph){graphTitle.textContent='Graph not found';graphPath.textContent='';graphSource.textContent='';graphCanvas.replaceChildren(element('p','error-state',text('Graph not found: '+selectedGraphId+'. Select Entry or another graph.')));return;}graphTitle.textContent=graph.name;graphPath.textContent=graph.path;graphSource.textContent=graph.source;graphCanvas.replaceChildren(element('p','subtle',text('Rendering…')));try{if(!window.mermaid)throw new Error('Mermaid renderer unavailable');if(!window.__relayMermaidReady){window.mermaid.initialize({startOnLoad:false,securityLevel:'strict',flowchart:{htmlLabels:false}});window.__relayMermaidReady=true;}const rendered=await window.mermaid.render('relay-graph-'+graph.id.replace(/[^A-Za-z0-9_-]/g,'-'),graph.source.replace(/^\\s*click\\s+[A-Za-z0-9_]+\\s+href\\s+\"[a-z0-9-]+\\.mmd\"\\s*$/gm,''));if(graph.id!==selectedGraphId)return;const svg=sanitizeGraphSvg(rendered.svg);graphCanvas.replaceChildren(svg);if(graph.id!=='entry'){const events=[...new Set([...graph.source.matchAll(/\\|on:\\s*([A-Za-z0-9_.-]+)\\|/g)].map(m=>m[1]))];const links=document.querySelector('#graph-links');for(const event of events){const button=element('button','refresh-button',text('Event: '+event));button.addEventListener('click',()=>graphDetail('Event',event));links.append(button);}}const definitions=graphNodeDefinitions(graph.source);for(const node of svg.querySelectorAll('g.node')){const entry=Array.from(definitions.entries()).find(([key])=>node.id.includes('-flowchart-'+key+'-'));const label=entry?.[1]||'';if(label)addNodeLabel(node,label);const target=entry?.[0];const next=target?graphLinks(graph.source).get(target):null;if(next){interactiveNode(node,()=>navigateGraph(next),'Explore '+target);}else{const match=/^(state|guard|action):\\s*([A-Za-z0-9_.-]+)/.exec(label);if(match)interactiveNode(node,()=>graphDetail(match[1]==='guard'?'Guard':match[1]==='action'?'Action':'State',match[2]),'Inspect '+match[1]+' '+match[2]);}}applyGraphPalette(svg);}catch(error){graphCanvas.replaceChildren(element('p','error-state',text('Visual preview unavailable: '+error.message+'. Mermaid source remains available below.')));}}
+function sanitizeGraphSvg(markup){const parsed=new DOMParser().parseFromString(markup.replace(/^<svg\\b/,'<svg xmlns:xlink="http://www.w3.org/1999/xlink"'),'image/svg+xml');const source=parsed.documentElement;if(source.localName!=='svg'||parsed.querySelector('parsererror'))throw new Error('Invalid SVG');const ns='http://www.w3.org/2000/svg';const elements=new Set(['svg','g','path','rect','circle','ellipse','line','polyline','polygon','text','tspan','defs','marker','title','desc','clipPath']);const attributes=new Set(['id','class','viewBox','width','height','x','y','x1','y1','x2','y2','cx','cy','r','rx','ry','d','points','transform','fill','stroke','stroke-width','stroke-dasharray','stroke-linecap','stroke-linejoin','opacity','fill-opacity','stroke-opacity','font-size','font-family','font-weight','text-anchor','dominant-baseline','markerWidth','markerHeight','markerUnits','refX','refY','orient','preserveAspectRatio','clip-path','marker-start','marker-mid','marker-end','role','aria-label']);const clean=node=>{if(node.nodeType===3)return document.createTextNode(node.textContent||'');if(node.nodeType!==1||node.namespaceURI!==ns||!elements.has(node.localName))return null;const out=document.createElementNS(ns,node.localName);for(const attr of node.attributes){if(!attr.namespaceURI&&attr.name==='style'){for(const declaration of attr.value.split(';')){const split=declaration.indexOf(':');if(split<0)continue;const property=declaration.slice(0,split).trim();const cssValue=declaration.slice(split+1).trim();if((property==='stroke'||property==='fill')&&/^(?:#[0-9a-fA-F]{3,8}|rgb\\([0-9.,%\\s]+\\)|none|currentColor)$/.test(cssValue))out.setAttribute(property,cssValue);else if(property==='stroke-width'&&/^[0-9]+(?:\\.[0-9]+)?(?:px)?$/.test(cssValue))out.setAttribute(property,cssValue);}continue;}if(attr.namespaceURI||!attributes.has(attr.name))continue;if(['marker-start','marker-mid','marker-end','clip-path'].includes(attr.name)){if(!attr.value.startsWith('url(#')||!attr.value.endsWith(')')||!(/^[a-zA-Z0-9_-]+$/.test(attr.value.slice(5,-1))))continue;}else if(attr.value.toLowerCase().includes('url(')||attr.value.includes('<')||attr.value.includes('>'))continue;out.setAttribute(attr.name,attr.value);}for(const child of node.childNodes){const safe=clean(child);if(safe)out.appendChild(safe);}return out;};return clean(source);}
+function applyGraphPalette(svg){const ns='http://www.w3.org/2000/svg';for(const path of svg.querySelectorAll('path')){if(path.closest('marker')){if(!path.hasAttribute('fill'))path.setAttribute('fill','#65768a');continue;}if(!path.hasAttribute('fill'))path.setAttribute('fill','none');if(!path.hasAttribute('stroke'))path.setAttribute('stroke','#65768a');}for(const node of svg.querySelectorAll('g.node')){const error=node.classList.contains('failure')||node.classList.contains('exception');for(const shape of node.querySelectorAll('rect,polygon,circle,ellipse')){shape.setAttribute('fill',error?'#ffe4e4':'#f9fbff');shape.setAttribute('stroke',error?'#be3030':'#657f9e');shape.setAttribute('stroke-width','1.3');}for(const label of node.querySelectorAll('text'))label.setAttribute('fill',node.classList.contains('drillable')?'#2367b1':error?'#7c1818':'#182536');}for(const rect of svg.querySelectorAll('rect')){if(!rect.closest('g.node')&&!rect.hasAttribute('fill'))rect.setAttribute('fill','#ffffff');}for(const label of svg.querySelectorAll('text'))if(!label.hasAttribute('fill'))label.setAttribute('fill','#182536');}
+async function renderSelectedGraph(){const graph=selectedWorkflowGraph();renderGraphNavigation();document.querySelector('#graph-detail').hidden=true;if(!graph){graphTitle.textContent='Graph not found';graphPath.textContent='';graphSource.textContent='';graphCanvas.replaceChildren(element('p','error-state',text('Graph not found: '+selectedGraphId+'. Select Entry or another graph.')));return;}graphTitle.textContent=graph.name;graphPath.textContent=graph.path;graphSource.textContent=graph.source;graphCanvas.replaceChildren(element('p','subtle',text('Rendering…')));try{if(!window.mermaid)throw new Error('Mermaid renderer unavailable');if(!window.__relayMermaidReady){window.mermaid.initialize({startOnLoad:false,securityLevel:'strict',flowchart:{htmlLabels:false}});window.__relayMermaidReady=true;}const rendered=await window.mermaid.render('relay-graph-'+graph.id.replace(/[^A-Za-z0-9_-]/g,'-'),graph.source.replace(/^\\s*click\\s+[^\\n]*$/gm,''));if(graph.id!==selectedGraphId)return;const svg=sanitizeGraphSvg(rendered.svg);graphCanvas.replaceChildren(svg);if(graph.id!=='entry'){const events=[...new Set([...graph.source.matchAll(/\\|on:\\s*([A-Za-z0-9_.-]+)\\|/g)].map(m=>m[1]))];const links=document.querySelector('#graph-links');for(const event of events){const button=element('button','refresh-button',text('Event: '+event));button.addEventListener('click',()=>graphDetail('Event',event));links.append(button);}}const definitions=graphNodeDefinitions(graph.source);for(const node of svg.querySelectorAll('g.node')){const entry=Array.from(definitions.entries()).find(([key])=>node.id.includes('-flowchart-'+key+'-'));const label=entry?.[1]||'';if(label)addNodeLabel(node,label);const target=entry?.[0];const next=target?graphLinks(graph.source).get(target):null;if(next){interactiveNode(node,()=>navigateGraph(next),'Explore '+target);}else{const match=/^(state|guard|action):\\s*([A-Za-z0-9_.-]+)/.exec(label);if(match)interactiveNode(node,()=>graphDetail(match[1]==='guard'?'Guard':match[1]==='action'?'Action':'State',match[2]),'Inspect '+match[1]+' '+match[2]);}}applyGraphPalette(svg);}catch(error){graphCanvas.replaceChildren(element('p','error-state',text('Visual preview unavailable: '+error.message+'. Mermaid source remains available below.')));}}
 async function drawGraphs(){try{const graphs=await loadJSON('/api/graphs');workflowGraphs=Array.isArray(graphs)?graphs:[];const requested=graphFromHash();selectedGraphId=requested||'main';graphsMeta.textContent=(workflowGraphs.length-1)+' executable workflow graphs · main is conceptual';renderGraphList();await renderSelectedGraph();}catch(error){graphsMeta.textContent='Unavailable';workflowGraphs=[];selectedGraphId='main';renderGraphList();await renderSelectedGraph();graphPath.textContent='Executable graphs unavailable: '+error.message;}}
 function renderAudit(records){auditLog.replaceChildren();if(!Array.isArray(records)||!records.length){auditLog.append(element('p','empty',text('No schema v5 routing decisions yet.')));return;}for(const record of records){const card=element('article','audit-entry');const head=element('div','audit-entry-head');head.append(element('strong','',text(routeWorker(record)+' · '+value(record?.selected?.model?.model))),element('span','subtle',text(new Date(record.timestamp).toLocaleString())));card.append(head);const correlation=record.correlation||{};card.append(element('div','subtle',text([correlation.job_id,correlation.task_id].filter(Boolean).join(' / ')||'uncorrelated')));const probabilities=record.decision_evidence?.probabilities||{};const gates=(record.gate_results||[]).filter(item=>!item.eligible).map(item=>item.candidate_id+': '+item.rejection_reasons.join(', '));const nl=String.fromCharCode(10);const details=document.createElement('pre');details.textContent='fallback: '+String(Boolean(record.decision_evidence?.fallback))+(Object.keys(probabilities).length?nl+'probabilities: '+JSON.stringify(probabilities,null,2):'')+(gates.length?nl+'rejected: '+gates.join(nl):'');card.append(details);auditLog.append(card);}}
 async function drawAudit(){auditRefresh.disabled=true;try{renderAudit(await loadJSON('/api/decision-audit'));}catch(error){auditLog.replaceChildren(element('p','error-state',text('Audit unavailable: '+error.message)));}finally{auditRefresh.disabled=false;}}

package/dist/dashboard-style.js

@@ -100,6 +100,7 @@ export const dashboardStyles = `  <style>
     .graph-canvas { min-height:24rem; display:grid; place-items:center; overflow:auto; padding:1rem; border:1px solid var(--border); border-radius:.45rem; background:var(--surface2); }
     .graph-canvas svg { max-width:none; height:auto; }
     .graph-canvas svg rect.background { display:none; }
+    .graph-canvas svg .edgeLabel rect, .graph-canvas svg .edgeLabel .labelBkg, .graph-canvas svg .edgeLabel .background { fill:transparent !important; opacity:0 !important; }
     .graph-navigation { display:flex; flex-wrap:wrap; align-items:center; gap:.5rem; margin-bottom:.7rem; }
     .graph-canvas .node.drillable { cursor:pointer; }
     .graph-canvas .node.drillable text, .graph-canvas .node.drillable tspan { fill:#2367b1; }

package/dist/escalation-notifier.js

@@ -0,0 +1,92 @@
+import { recordEscalationNotificationDelivery } from './task-recovery.js';
+function receiptValid(value) {
+    return typeof value.channel === 'string' && value.channel.trim().length > 0
+        && typeof value.deliveryId === 'string' && value.deliveryId.trim().length > 0
+        && typeof value.deliveredAt === 'string' && Number.isFinite(Date.parse(value.deliveredAt));
+}
+/** Configured trusted downstream notifier. HTTP success alone is never a delivery receipt. */
+export function escalationNotifierFromEnvironment(env = process.env) {
+    const raw = env.AGENTS_RELAY_ESCALATION_NOTIFY_URL?.trim();
+    if (!raw)
+        return undefined;
+    const url = new URL(raw);
+    if (url.username || url.password || url.hash || !(url.protocol === 'https:' || (url.protocol === 'http:' && ['localhost', '127.0.0.1', '::1', '[::1]'].includes(url.hostname))))
+        throw Error('Escalation notifier requires HTTPS or a loopback HTTP endpoint without URL credentials');
+    const token = env.AGENTS_RELAY_ESCALATION_NOTIFY_TOKEN?.trim();
+    return async (request) => {
+        const response = await fetch(url, { method: 'POST', redirect: 'error',
+            signal: AbortSignal.timeout(10000),
+            headers: { 'Content-Type': 'application/json', 'Idempotency-Key': request.idempotencyKey,
+                ...(token ? { 'Authorization': `Bearer ${token}` } : {}) },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok)
+            throw Error(`Notification endpoint HTTP ${response.status}`);
+        const body = await response.json();
+        if (body.delivered !== true || !receiptValid(body))
+            throw Error('Notification endpoint did not provide a verified delivery ID');
+        return { channel: body.channel, deliveryId: body.deliveryId, deliveredAt: body.deliveredAt };
+    };
+}
+const retryDelayMs = (attempts) => Math.min(3600000, 60000 * 2 ** Math.min(6, Math.max(0, attempts - 1)));
+function pending(notification) {
+    return notification.status === 'pending' && notification.notification?.status !== 'delivered';
+}
+/** Durable delivery-attempt ledger; a transport ACK without provider receipt leaves status pending. */
+export async function deliverPendingEscalations(store, jobId, notifier, now = new Date()) {
+    const job = await store.load(jobId);
+    const result = { delivered: 0, pending: 0, failed: 0 };
+    const candidates = job.tasks.filter(t => t.agentName === 'troubleshooter' && t.escalation && pending(t.escalation));
+    if (candidates.length > 0 && !store.mutateJob) {
+        if (notifier)
+            throw Error('Escalation delivery with an actual notifier requires atomic SQLite mutation');
+        return { delivered: 0, pending: candidates.length, failed: 0 };
+    }
+    for (const task of candidates) {
+        const escalation = task.escalation;
+        const details = escalation.notification ?? {};
+        if (typeof details.nextAttemptAt === 'string' && Date.parse(details.nextAttemptAt) > now.getTime()) {
+            result.pending++;
+            continue;
+        }
+        if (!notifier) {
+            if (details.lastError !== 'Notification delivery channel is not configured') {
+                await store.mutateJob(jobId, current => {
+                    const candidate = current.tasks.find(t => t.id === task.id);
+                    if (candidate?.escalation?.id === escalation.id && pending(candidate.escalation))
+                        candidate.escalation.notification = { ...candidate.escalation.notification, status: 'pending', lastError: 'Notification delivery channel is not configured' };
+                    return current;
+                });
+            }
+            result.pending++;
+            continue;
+        }
+        const request = {
+            jobId, taskId: task.id, escalationId: escalation.id,
+            idempotencyKey: `escalation/${escalation.id}`,
+            requiredAction: escalation.requiredAction, resolutionCondition: escalation.resolutionCondition, context: escalation.context,
+        };
+        try {
+            const receipt = await notifier(request);
+            if (!receiptValid(receipt))
+                throw Error('Notifier returned no verifiable delivery receipt');
+            await recordEscalationNotificationDelivery(store, jobId, task.id, escalation.id, receipt);
+            result.delivered++;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await store.mutateJob(jobId, current => {
+                const candidate = current.tasks.find(t => t.id === task.id);
+                if (candidate?.escalation?.id !== escalation.id || !pending(candidate.escalation))
+                    return current;
+                const previous = candidate.escalation.notification ?? {};
+                const attempts = (typeof previous.attempts === 'number' ? previous.attempts : 0) + 1;
+                candidate.escalation.notification = { ...previous, status: 'pending', attempts, lastError: message,
+                    lastAttemptAt: now.toISOString(), nextAttemptAt: new Date(now.getTime() + retryDelayMs(attempts)).toISOString() };
+                return current;
+            });
+            result.failed++;
+        }
+    }
+    return result;
+}

package/dist/local-authority-store.js

@@ -28,6 +28,35 @@ export class LocalAuthorityDurableStore {
         this.noGitHub = noGitHub;
         this.projection = new GitHubProjectionWriter(authority, github, undefined, true);
     }
+    async reserveWorkflowLaunch(identity) {
+        if (!this.authority.reserveWorkflowLaunch)
+            throw Error('authoritative workflow launch ledger unavailable');
+        return this.authority.reserveWorkflowLaunch(identity);
+    }
+    async verifyWorkflowLaunch(jobId, taskId, executionId) {
+        if (!this.authority.verifyWorkflowLaunch)
+            throw Error('authoritative workflow launch verifier unavailable');
+        return this.authority.verifyWorkflowLaunch(jobId, taskId, executionId);
+    }
+    async commitWorkflowMutationAndEvents(jobId, mutation, events) {
+        if (!this.authority.commitWorkflowMutationAndEvents)
+            throw new Error('SQLite workflow outbox capability unavailable');
+        const committed = await this.authority.commitWorkflowMutationAndEvents(jobId, mutation, events);
+        publishLocalCommit(committed);
+        return structuredClone(committed);
+    }
+    async commitWorkflowMutationWithEvents(jobId, mutation) {
+        if (!this.authority.commitWorkflowMutationWithEvents)
+            throw Error('SQLite workflow outbox capability unavailable');
+        const result = await this.authority.commitWorkflowMutationWithEvents(jobId, mutation);
+        publishLocalCommit(result);
+        return structuredClone(result);
+    }
+    async drainWorkflowEvents(publish) {
+        if (!this.authority.drainWorkflowEvents)
+            throw new Error('SQLite workflow outbox capability unavailable');
+        return this.authority.drainWorkflowEvents(publish);
+    }
     /** Queue one retryable PR merge; do not mutate Job lifecycle until external confirmation. */
     async mergePullRequest(expectedHeadSha) {
         if (this.noGitHub)

package/dist/local-merge-delivery.js

@@ -1,9 +1,10 @@
+import { createHash } from 'node:crypto';
 import { eventFor } from './events.js';
 import { transitionJobEvent } from './scheduler.js';
 import { deliverLocalMerge, localMergeEligible, requiresLocalGitMerge } from './local-git-merge.js';
 import { errorMessage } from './observability.js';
 /** Graph-selected durable local merge and completion; no checked-out worktree is ever changed. */
-export async function reconcileLocalGitCompletion(store, finalState, headSha, noGitHub, projectPathForJob, emit) {
+export async function reconcileLocalGitCompletion(store, finalState, headSha, noGitHub, projectPathForJob, emit, mergeEffect = deliverLocalMerge, now = Date.now) {
     if (localMergeEligible(finalState) && !requiresLocalGitMerge(finalState)) {
         await transitionJobEvent(finalState, 'local.completed', { localCompletionAllowed: true });
         await store.saveJob(finalState);
@@ -14,7 +15,7 @@ export async function reconcileLocalGitCompletion(store, finalState, headSha, no
         const receipt = finalState.localMerge;
         let activeReceipt = receipt;
         if (receipt.status !== 'succeeded' &&
-            (!receipt.nextAttemptAt || Date.parse(receipt.nextAttemptAt) <= Date.now())) {
+            (!receipt.nextAttemptAt || Date.parse(receipt.nextAttemptAt) <= now())) {
             await transitionJobEvent(finalState, 'local.merge.requested', { localMergeReady: true }, async (actionId) => {
                 if (actionId !== 'effect.deliverLocalMerge')
                     throw new Error('Unsupported local merge Graph effect ' + actionId);
@@ -28,7 +29,7 @@ export async function reconcileLocalGitCompletion(store, finalState, headSha, no
                     if (!projectPathForJob)
                         throw new Error('Local Git merge requires an explicit project path');
                     const repoPath = await projectPathForJob(finalState);
-                    const delivered = deliverLocalMerge(repoPath, { ...activeReceipt, sourceSha: activeReceipt.sourceSha ?? headSha ?? undefined,
+                    const delivered = mergeEffect(repoPath, { ...activeReceipt, sourceSha: activeReceipt.sourceSha ?? headSha ?? undefined,
                         correlationJobId: finalState.id, displayPrNumber: finalState.prNumber > 0 ? finalState.prNumber : undefined });
                     finalState.localMerge = { ...activeReceipt, ...delivered, status: 'succeeded', projectionStrategy: 'target_ref_push',
                         error: undefined, nextAttemptAt: undefined, updatedAt: new Date().toISOString() };
@@ -37,17 +38,39 @@ export async function reconcileLocalGitCompletion(store, finalState, headSha, no
                     const attempts = (activeReceipt.attempts ?? 0) + 1;
                     finalState.localMerge = { ...activeReceipt, status: 'failed', attempts,
                         error: errorMessage(error),
-                        nextAttemptAt: new Date(Date.now() + Math.min(300_000, 1000 * (2 ** Math.min(attempts, 8)))).toISOString(),
+                        nextAttemptAt: new Date(now() + Math.min(300_000, 1000 * (2 ** Math.min(attempts, 8)))).toISOString(),
                         updatedAt: new Date().toISOString() };
                 }
                 finalState.updatedAt = new Date().toISOString();
-                await store.saveJob(finalState);
                 const merge = finalState.localMerge;
-                if (merge && emit) {
-                    const succeeded = merge.status === 'succeeded';
-                    const reason = merge.error?.includes('tracked or index changes') ? 'dirty_target_worktree' : 'merge_delivery_failed';
-                    await emit(eventFor(finalState.id, 'merge', null, succeeded ? 'job.merge.succeeded' : 'job.merge.failed', succeeded ? 'succeeded' : 'failed', succeeded ? 'Local merge succeeded' : (merge.error ?? 'Local merge failed'), 'user', succeeded ? { mergedCommitSha: merge.mergedCommitSha, sourceSha: merge.sourceSha }
-                        : { reason, message: merge.error, attempts: merge.attempts, retryable: true, nextAttemptAt: merge.nextAttemptAt }, { id: `job/${finalState.id}/task/merge/execution/attempt-${merge.attempts ?? 0}`, agent: 'relay' }));
+                if (!merge)
+                    throw new Error('Graph local merge effect produced no receipt');
+                const succeeded = merge.status === 'succeeded';
+                const reason = merge.error?.includes('tracked or index changes') ? 'dirty_target_worktree' : 'merge_delivery_failed';
+                // Event identity is deterministic for one committed effect outcome.
+                const idempotencyBasis = `${finalState.id}:${merge.sourceSha ?? ''}:${merge.attempts ?? 0}:${merge.status}:${merge.mergedCommitSha ?? ''}`;
+                const eventKey = `workflow-local-merge-${createHash('sha256').update(idempotencyBasis).digest('hex')}`;
+                const outcomeEvent = eventFor(finalState.id, 'merge', null, succeeded ? 'job.merge.succeeded' : 'job.merge.failed', succeeded ? 'succeeded' : 'failed', succeeded ? 'Local merge succeeded' : (merge.error ?? 'Local merge failed'), 'user', succeeded ? { mergedCommitSha: merge.mergedCommitSha, sourceSha: merge.sourceSha }
+                    : { reason, message: merge.error, attempts: merge.attempts, retryable: true, nextAttemptAt: merge.nextAttemptAt }, { id: `job/${finalState.id}/task/merge/execution/attempt-${merge.attempts ?? 0}`, agent: 'relay' });
+                outcomeEvent.event_id = eventKey;
+                if (store.commitWorkflowMutationAndEvents) {
+                    // Persist only the Graph-selected merge receipt into the latest
+                    // authoritative Job; never replace concurrent Task/Review changes.
+                    const current = await store.commitWorkflowMutationAndEvents(finalState.id, existing => {
+                        if (existing.state !== 'ACTIVE' || !existing.localMerge
+                            || existing.localMerge.sourceRef !== receipt.sourceRef
+                            || existing.localMerge.targetRef !== receipt.targetRef
+                            || existing.localMerge.status === 'succeeded')
+                            throw new Error('stale local merge outcome');
+                        existing.localMerge = structuredClone(merge);
+                        existing.updatedAt = finalState.updatedAt;
+                        return existing;
+                    }, [{ key: eventKey, event: outcomeEvent }]);
+                    Object.assign(finalState, structuredClone(current));
+                }
+                else {
+                    await store.saveJob(finalState);
+                    await emit?.(outcomeEvent);
                 }
             });
         }

package/dist/planner-child-recovery.js

@@ -0,0 +1,44 @@
+import { materializePlannerChild } from './planner.js';
+import { attachResolutionOwnership } from './workflow/task-resolution.js';
+/** Recover persisted child definitions without inventing new task identities. */
+export async function recoverPlannerChildren(store, job, plannerContext) {
+    for (const plan of (job.plans ?? []).filter(item => item.status === 'SUCCEEDED' && item.plannerResult)) {
+        const executionContext = await plannerContext(job, plan);
+        // Historical plans were validated on commit. Rechecking against later Task failures
+        // blocks recovery before the Troubleshooter graph can run.
+        const children = plan.plannerResult.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
+        for (const child of children) {
+            const existing = job.tasks.find(item => item.id === child.id);
+            if (existing)
+                continue;
+            const spec = plan.plannerResult.next_tasks.find(item => item.id === child.id);
+            if (spec?.resolution)
+                await store.saveTask(attachResolutionOwnership(job, child, spec.resolution, 'planner'));
+            await store.appendTask(child);
+            job.tasks.push(child);
+        }
+    }
+    const historicalPlanners = job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult);
+    if (historicalPlanners.length === 0)
+        return;
+    const executionContext = await plannerContext(job, historicalPlanners[0]);
+    for (const planner of historicalPlanners) {
+        const result = planner.plannerResult;
+        const plan = { jobId: job.id, id: planner.id, round: planner.planningRound ?? 1, source: planner.planningSource ?? 'model-planner', previousPlanId: planner.previousPlannerTaskId ?? null, trigger: planner.planTrigger ?? { source: 'continuation' }, status: 'SUCCEEDED', guidance: planner.plannerGuidance, objectiveStatus: result.objective_status, plannerResult: result, assessment: result.assessment, generatedTaskIds: result.next_tasks.map(item => item.id), headSha: planner.planTrigger?.currentHeadSha ?? job.headSha, attempt: planner.attempt, maxAttempts: planner.maxAttempts, leaseOwner: null, leaseExpiresAt: null, executionId: null, timeoutMs: planner.timeoutMs, manualPlanning: planner.manualPlanning, createdAt: planner.createdAt, updatedAt: planner.updatedAt };
+        if (!(job.plans ?? []).some(item => item.id === plan.id)) {
+            await store.appendPlan(plan);
+            (job.plans ??= []).push(plan);
+        }
+        else
+            continue;
+        const children = result.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
+        for (const child of children)
+            if (!job.tasks.some(item => item.id === child.id)) {
+                const spec = result.next_tasks.find(item => item.id === child.id);
+                if (spec?.resolution)
+                    await store.saveTask(attachResolutionOwnership(job, child, spec.resolution, 'planner'));
+                await store.appendTask(child);
+                job.tasks.push(child);
+            }
+    }
+}

package/dist/planner-recovery.js

@@ -0,0 +1,30 @@
+import { taskOverallTimeoutMs } from './types.js';
+import { createTaskEntity } from './workflow/entity-creation.js';
+/** Only the Planner orchestration Graph may select this durable recovery effect. */
+export function createFailedPlanRecovery(job, plan) {
+    if (plan.status !== 'FAILED')
+        throw Error('Plan recovery requires a terminal FAILED Plan');
+    const id = 'recover-' + plan.id;
+    if (job.tasks.some(task => task.id === id || task.recoveryPlanId === plan.id))
+        throw Error('Plan recovery identity already exists');
+    const now = new Date().toISOString();
+    return createTaskEntity(job, {
+        jobId: job.id, id, title: 'Diagnose and recover failed Planner round',
+        recoveryPlanId: plan.id,
+        kind: 'work', priority: 'P0', storySize: 'M', projectName: job.title,
+        agentName: 'troubleshooter', parentTaskId: null, dependencies: [],
+        capabilities: ['troubleshoot', 'recovery'],
+        workerRequirements: { capabilities: ['model', 'local_repo', 'iterative_tools'], runtime: 'codex' },
+        adapter: 'codex',
+        input: `Recover FAILED Plan ${plan.id} in Job ${job.id}, repository ${job.repository}.
+Original Plan failure: ${plan.error ?? plan.assessment}.
+Inspect durable Plan history and original model/runtime error; repair or verify the actual blocker.
+Do not fabricate Planner success, create another Job, or publish blocked.
+Report task.completed only after verified technical recovery, with data.verified=true and non-empty data.evidence explaining the repair.
+Relay will create a NEW authoritative Plan round after your completed recovery evidence; it will not re-label the FAILED Plan as successful.`,
+        output: { kind: 'task_pr' }, continuation: null, continuationDeliveredAt: null,
+        attempt: 0, maxAttempts: 3, leaseOwner: null, leaseExpiresAt: null,
+        executionId: null, threadId: null, result: null, plannerResult: null, error: null,
+        timeoutMs: taskOverallTimeoutMs('M'), createdAt: now, updatedAt: now,
+    });
+}

package/dist/reconciler-review.js

@@ -14,6 +14,10 @@ import { reviewGenerationMatches } from './review-generation-fence.js';
 import { codexFallbackRouting, quarantineUnavailableCodexFallback } from './chatgpt-platform-fallback.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) {
+        // Tests may replace the external Git effect entirely; in that case its
+        // immutable input SHA is already present in the authoritative Job.
+        if (this.options.noGitHub && this.options.localMergeEffect)
+            return job.headSha ?? job.review?.headSha ?? null;
         // GitHub PR head facts are audit-only. Source identity is local Git.
         if (!this.options.projectPathForJob)
             return job.headSha ?? job.review?.headSha ?? null;
@@ -463,6 +467,11 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             await this.store.saveTask(task);
             await this.store.saveJob(job);
         }
+        if (event.type === 'review.started' && this.store.verifyWorkflowLaunch) {
+            const outcome = await this.store.verifyWorkflowLaunch(job.id, task.id, task.executionId);
+            if (outcome === 'Failed')
+                throw Error('reviewer start postcondition violated');
+        }
         // Review approval records evidence only. The subsequent Graph reconcile
         // drives durable local Git merge delivery and terminalization.
         if (outcome === 'approved')

package/dist/reconciler-runtime.js

@@ -124,7 +124,7 @@ export class ReconcilerRuntimeBase {
             return async () => { };
         }
     }
-    async idle() { while ([...this.live.values()].some(item => !item.processSettled) || this.plannerLive.size > 0 || this.continuationLive.size > 0 || this.reconciling || !this.eventCoordinator.isIdle())
+    async idle() { while ([...this.live.values()].some(item => !item.processSettled) || this.plannerLive.size > 0 || this.continuationLive.size > 0 || this.reconciling || this.detachedReconciles.size > 0 || !this.eventCoordinator.isIdle())
         await new Promise(resolve => setTimeout(resolve, 25)); }
     async close() {
         await this.eventCoordinator.settle();
@@ -220,6 +220,12 @@ export class ReconcilerRuntimeBase {
         });
         if (!transition?.decision.accepted)
             return { applied: false, reconcile: false, reason: 'task.started.ignored' };
+        if (this.store.verifyWorkflowLaunch && transition.task.executionId) {
+            const outcome = await this.store.verifyWorkflowLaunch(event.job_id, event.task_id, transition.task.executionId);
+            if (outcome === 'Failed')
+                throw Error('worker start postcondition violated');
+            // Unknown remains durable and never authorizes repeating this generation.
+        }
         if (live?.executionId === transition.task.executionId)
             live.workerStarted = true;
         return { applied: true, reconcile: transition.from === 'FAILED', reason: transition.from === 'FAILED' ? 'task.started.recovery' : 'task.started', reconcileMode: transition.from === 'FAILED' ? 'detached' : undefined };

package/dist/reconciler-workflow-outbox.js

@@ -0,0 +1,11 @@
+/** Propagate transport failures. Pending SQLite events replay after restart. */
+export async function drainProductionWorkflowOutbox(store, options) {
+    if (!store.drainWorkflowEvents || (!options.eventBus && !options.emit))
+        return 0;
+    return store.drainWorkflowEvents(async (event) => {
+        if (options.eventBus)
+            await options.eventBus.publish(event);
+        if (options.emit)
+            await options.emit(event);
+    });
+}