agents-relay 2.0.156 → 2.0.158

package/dist/blockers.js

@@ -1,5 +1,5 @@
-import { applyTaskReleaseAction, applyTaskUnblockRetryAction, dispatchTaskAction } from './task-actions.js';
-import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
+import { applyTaskReleaseAction } from './task-actions.js';
+import { isEffectivelyBlocked } from './unblock.js';
 import { dispatchBlockerResolution } from './workflow/blocker-resolution-v2.js';
 import { dispatchTaskResolutionSync, materializeResolution } from './workflow/task-resolution.js';
 function dependentKey(value) {
@@ -99,47 +99,25 @@ export async function resolveBlockerDependencies(options) {
             loadError = error instanceof Error ? error.message : String(error);
         }
         const targetMatches = !!task && ['DRAFT', 'FAILED', 'BLOCKED', 'QUEUED'].includes(task.state) && task.attempt === relation.blockedAttempt;
-        let note = 'dependent task requeued';
+        let note = 'dependent task released from dependency wait';
         const decision = await dispatchBlockerResolution({
             resolutionAllowed: !(mode === 'verified' && options.resolution !== 'verified'),
             targetMatches,
             autonomousJob: targetJob?.executionMode === 'autonomous',
             effectivelyBlocked: !!task && isEffectivelyBlocked(task),
             alreadyUnblocked: Boolean(task?.unblock && ['DRAFT', 'QUEUED'].includes(task.state)),
-            isDraft: task?.state === 'DRAFT', isBlocked: task?.state === 'BLOCKED',
+            isDraft: task?.state === 'DRAFT', isBlocked: Boolean(task && isEffectivelyBlocked(task)),
             isFailed: task?.state === 'FAILED', isUnblocked: Boolean(task?.unblock && ['DRAFT', 'QUEUED'].includes(task.state)),
         }, async (actionId) => {
             if (!targetJob || !task)
                 throw new Error('Blocker graph requested action without a matching dependent task');
-            if (actionId === 'blocker.autonomousUnblock') {
-                await unblockAutonomousTasks({ store, job: targetJob, tasks: [task], trigger: { source: 'blocker_job', reason: 'Blocker Job ' + blocker.id + ' resolved (' + options.resolution + ')', blockerJobId: blocker.id, resolution: options.resolution }, now });
-                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
-                note = 'dependent task unblocked for replanning';
-            }
-            else if (actionId === 'blocker.acceptExistingUnblock')
-                note = 'dependent Job already unblocked for replanning';
-            else if (actionId === 'blocker.releaseDraft') {
+            if (actionId === 'blocker.releaseDraft') {
                 await applyTaskReleaseAction(task);
                 task.error = null;
                 task.updatedAt = now;
                 delete task.blockedBy;
                 await store.saveTask(task);
             }
-            else if (actionId === 'blocker.unblockTask') {
-                await unblockTask({ store, job: targetJob, task, trigger: { source: 'blocker_job', reason: 'Blocker Job ' + blocker.id + ' resolved (' + options.resolution + ')', blockerJobId: blocker.id, resolution: options.resolution }, now });
-                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
-            }
-            else if (actionId === 'blocker.retryFailed') {
-                const result = await dispatchTaskAction(store, { id: 'task.retry', jobId: targetJob.id, taskId: task.id });
-                delete result.task.blockedBy;
-                result.task.updatedAt = now;
-                await store.saveTask(result.task);
-            }
-            else if (actionId === 'blocker.retryUnblocked') {
-                await applyTaskUnblockRetryAction(task);
-                task.updatedAt = now;
-                await store.saveTask(task);
-            }
             else
                 throw new Error('Unsupported blocker graph action ' + actionId);
             return {};
@@ -160,6 +138,7 @@ export async function resolveBlockerDependencies(options) {
         relation.resolvedAt = now;
         relation.resolution = options.resolution;
         relation.note = note;
+        unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
         resumed += 1;
     }
     const remaining = relations.filter(relation => relation.state === 'waiting');

package/dist/chatgpt-platform-fallback.js

@@ -32,7 +32,7 @@ export async function quarantineUnavailableCodexFallback(transitions, emit, jobI
         mutate: (_job, task) => { task.error = `Codex fallback route became unavailable: ${error instanceof Error ? error.message : String(error)}`; },
     });
     if (transition?.decision.accepted)
-        await emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.blocked', 'blocked', transition.task.error ?? 'Codex fallback route unavailable', 'user', { reason: transition.task.failureReason, phase: 'fallback-routing' }));
+        await emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? 'Codex fallback route unavailable', 'user', { reason: transition.task.failureReason, phase: 'fallback-routing' }));
 }
 export function persistChatGptPlatformFailure(task, original, executionId, classification, evidence, safeToReroute) {
     const route = original?.routing;

package/dist/cli-help.js

@@ -9,7 +9,7 @@ Usage:
 
 Commands:
   job create|update|show|list|merge|unblock|cancel|pause|resume  Manage SQLite-authoritative jobs with optional GitHub PRs
-  task create|update|show|list|complete|retry|unblock|cancel  Manage durable tasks
+  task create|update|show|list|classify|complete|retry|unblock|cancel  Manage durable tasks
   review request           Request graph-owned review (optional thread override)
   plan                     Invoke the Planner for an existing managed Job
   plan apply               Submit a validated Task Tree within one active Plan
@@ -93,7 +93,7 @@ Example:
     'job merge': `Request an idempotent external pull-request merge; return QUEUED until confirmed, when the Graph Engine completes the Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. The current PR head SHA is pinned into the merge request.`,
-    'job unblock': `Authoritatively unblock the effective BLOCKED work Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Autonomous Jobs move blocked work to planner-waiting DRAFT with durable unblock facts; fixed Jobs resume directly as QUEUED with a reset retry budget.`,
+    'job unblock': `Authoritatively unblock BLOCKED Troubleshooter Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Each unblocked Troubleshooter is queued as the same Task and must rerun, verify the condition, and issue a fresh resolution before retrying an original failed Task.`,
     'job cancel': `Cancel the durable Job and close its backing pull request.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. Nonterminal Tasks are cancelled before the PR is closed.`,
@@ -166,15 +166,14 @@ Optional: --failure-kind adapter_failure|model_failure|provider_failure|task_fai
     'task cancel': `Cancel one durable Task.
 
 Required: --task-id ID and the normal Job storage options.`,
-    'task supersede': `Mark an already-CANCELLED durable Task as superseded by later corrected work through the Task Resolution Graph.
-
-Required: --task-id ID, --reason TEXT, and the normal managed Job storage options. This does not change Task state and cannot supersede FAILED/BLOCKED/runnable work.`,
+    'task supersede': `Mark an already-CANCELLED durable Task as superseded by later corrected work through the Task Resolution Graph.\n\nRequired: --task-id ID, --reason TEXT, and the normal managed Job storage options. This does not change Task state and cannot supersede FAILED/BLOCKED/runnable work.`,
+    'task classify': `Classify a FAILED work Task as superseded or invalid without changing its Task lifecycle.\n\nRequired: --task-id ID --classification superseded|invalid --target-task-id ID --evidence TEXT --reason TEXT and the normal Job storage options. Unknown or active execution outcomes are rejected.`,
     plan: `Invoke the Planner against the current durable Job state.
 
 Agent submit: agents-relay plan apply --repo OWNER/REPO --pr PR_NUMBER --id JOB_ID --plan-id PLAN_ID --execution-id EXECUTION_ID --file plan.json. Validation errors reject without partial task writes and can be corrected inside the same Planner execution.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
-Optional: --prompt TEXT or --prompt-file PATH|- (mutually exclusive). The prompt is additional guidance for this planning round and never replaces the durable Job objective.
+Optional: --prompt TEXT or --prompt-file PATH|- (mutually exclusive). The prompt is additional guidance for this planning round and never replaces the durable Job objective. --force-clean-history --clean-history-file PATH requires explicit {taskId,kind,targetTaskId,evidence,reason} records for every unclassified FAILED work Task; it applies graph-authorized classifications and creates the new Plan in one SQLite mutation. Unknown execution outcomes fail closed. Planner proposals must be committed with plan apply; final text is never applied as a Plan.
 
 The command persists one real plan-N round, materializes validated next_tasks with planner provenance, and wakes normal reconciliation. It works for zero-task DRAFT Jobs. Historical planner-N rounds remain readable, but new rounds use plan-N.
 

package/dist/cli-plan-clean-history.js

@@ -0,0 +1,16 @@
+import { readFile } from 'node:fs/promises';
+import { arg, hasArg } from './cli-support.js';
+export async function cleanHistoryOption(args) {
+    const force = hasArg([...args], '--force-clean-history');
+    const path = arg([...args], '--clean-history-file');
+    if (!force && path)
+        throw new Error('--clean-history-file requires --force-clean-history');
+    if (force && !path)
+        throw new Error('--force-clean-history requires --clean-history-file with one classification per FAILED Task');
+    if (!path)
+        return undefined;
+    const value = JSON.parse(await readFile(path, 'utf8'));
+    if (!Array.isArray(value) || value.some(item => !item || typeof item !== 'object' || Array.isArray(item)))
+        throw new Error('--clean-history-file must contain a JSON array of classification objects');
+    return value;
+}

package/dist/cli-unblock.js

@@ -1,5 +1,5 @@
 import { arg, publishTaskUnblocked, publishWake, saveLocal, withEventBus } from './cli-support.js';
-import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
+import { isEffectivelyBlocked, unblockTask } from './unblock.js';
 import { resumeTroubleshooter } from './task-recovery.js';
 export async function runTaskUnblockCommand(args, store, job, task, localFile) {
     const reason = arg(args, '--reason');
@@ -29,24 +29,13 @@ export async function runJobUnblockCommand(args, store, job) {
     const blocked = job.tasks.filter(isEffectivelyBlocked);
     if (blocked.length === 0)
         throw new Error(`Job ${job.id} has no effective BLOCKED work task`);
-    if (job.executionMode === 'autonomous') {
-        const planTrigger = await unblockAutonomousTasks({ store, job, tasks: blocked, trigger: { source: 'cli', reason } });
-        const refreshed = await store.load(job.id);
-        await withEventBus(args, async (bus) => {
-            for (const task of blocked)
-                await publishTaskUnblocked(bus, refreshed, task.id, reason);
-            await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked for replanning`);
-        });
-        console.log(JSON.stringify({ jobId: job.id, replanning: true, planTrigger }, null, 2));
-        return;
-    }
     for (const task of blocked)
         await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
     const refreshed = await store.load(job.id);
     await withEventBus(args, async (bus) => {
         for (const task of blocked)
             await publishTaskUnblocked(bus, refreshed, task.id, reason);
-        await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked`);
+        await publishWake(bus, refreshed, 'job', `Troubleshooter work in Job ${job.id} resumed`);
     });
-    console.log(JSON.stringify({ jobId: job.id, replanning: false, resumedTasks: blocked.map(task => task.id) }, null, 2));
+    console.log(JSON.stringify({ jobId: job.id, resumedTasks: blocked.map(task => task.id) }, null, 2));
 }

package/dist/cli-worker-task.js

@@ -2,6 +2,17 @@ import { taskOverallTimeoutMs } from './types.js';
 import { arg, hasArg, textOption, integerArg, chatGptTabClosePolicy, storySize, priority, continuation } from './cli-support.js';
 import { parseAgentGraph } from './agent-graph.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
+export function recoveryDiagnosisFromArgs(args) {
+    const failureKind = arg(args, '--failure-kind');
+    if (!failureKind)
+        return undefined;
+    const reason = arg(args, '--reason');
+    if (!reason.trim())
+        throw new Error('--failure-kind requires --reason');
+    if (!['adapter_failure', 'model_failure', 'provider_failure', 'task_failure', 'unknown'].includes(failureKind))
+        throw new Error('Invalid --failure-kind');
+    return { failureKind, reason, evidence: arg(args, '--evidence') || undefined, reroute: hasArg(args, '--reroute'), excludeCurrentRoute: hasArg(args, '--exclude-current-route') };
+}
 export async function workerTaskFromArgs(job, args, now) {
     const model = arg(args, '--model');
     const adapterValue = arg(args, '--adapter');

package/dist/cli.js

@@ -23,6 +23,8 @@ import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { applyTaskHoldAction, applyTaskQueueAction, dispatchTaskAction } from './task-actions.js';
 import { applyJobActivateAction, applyJobCancelAction } from './job-actions.js';
+import { classifyFailedTask } from './task-actions.js';
+import { cleanHistoryOption } from './cli-plan-clean-history.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { startServiceExternalActionFlusher } from './service-external-actions.js';
 import { handleServicePublication } from './service-publication.js';
@@ -42,7 +44,7 @@ import { normalizeThreadId, runtimeReviewer } from './reviewer-thread.js';
 export { runtimeReviewer } from './reviewer-thread.js';
 import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, eventBus, publishWake, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayControlCommand, relayJobList, relayJobStateCommand, relayTaskCommand, withEventBus } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
-import { workerTaskFromArgs } from './cli-worker-task.js';
+import { recoveryDiagnosisFromArgs, workerTaskFromArgs } from './cli-worker-task.js';
 import { taskExecutionContext } from './task-context.js';
 import { requestTroubleshooterEscalation, resumeTroubleshooter } from './task-recovery.js';
 import { pauseJob, resumeJob } from './job-pause.js';
@@ -72,20 +74,8 @@ async function runManagedTaskCommand(action, args) {
         throw new Error(`Task ${id} missing after ${action}`);
     console.log(JSON.stringify(task, null, 2));
 }
-function recoveryDiagnosisFromArgs(args) {
-    const failureKind = arg(args, '--failure-kind');
-    if (!failureKind)
-        return undefined;
-    const reason = arg(args, '--reason');
-    if (!reason.trim())
-        throw new Error('--failure-kind requires --reason');
-    if (!['adapter_failure', 'model_failure', 'provider_failure', 'task_failure', 'unknown'].includes(failureKind))
-        throw new Error('Invalid --failure-kind');
-    const reroute = args.includes('--reroute');
-    return { failureKind, reason, evidence: arg(args, '--evidence') || undefined, reroute, excludeCurrentRoute: args.includes('--exclude-current-route') };
-}
 async function runTaskCommand(action, args) {
-    if (!['create', 'update', 'show', 'context', 'comment', 'comments', 'list', 'retry', 'recover', 'unblock', 'escalate', 'resume-troubleshooter', 'cancel', 'supersede'].includes(action))
+    if (!['create', 'update', 'show', 'context', 'comment', 'comments', 'list', 'retry', 'recover', 'unblock', 'escalate', 'resume-troubleshooter', 'cancel', 'supersede', 'classify'].includes(action))
         throw new Error(usage);
     const managed = !arg(args, '--file') && Boolean(arg(args, '--repo') && arg(args, '--id'));
     if (managed) {
@@ -130,6 +120,16 @@ async function runTaskCommand(action, args) {
             console.log(JSON.stringify(task, null, 2));
             return;
         }
+        if (action === 'classify') {
+            if (!taskId)
+                throw new Error('task classify requires --task-id');
+            const kind = arg(args, '--classification');
+            if (kind !== 'superseded' && kind !== 'invalid')
+                throw new Error('--classification must be superseded or invalid');
+            const result = await relayControlCommand(args, { command: 'task.classify', jobId, taskId, classification: { kind, targetTaskId: arg(args, '--target-task-id'), evidence: await textOption(args, '--evidence', '--evidence-file'), reason: await textOption(args, '--reason', '--reason-file') } });
+            console.log(JSON.stringify(result.tasks.find(item => item.id === taskId), null, 2));
+            return;
+        }
         if (['create', 'retry', 'cancel'].includes(action)) {
             await runManagedTaskCommand(action, args);
             return;
@@ -262,6 +262,15 @@ async function runTaskCommand(action, args) {
         console.log(JSON.stringify(task, null, 2));
         return;
     }
+    if (action === 'classify') {
+        const kind = arg(args, '--classification');
+        if (kind !== 'superseded' && kind !== 'invalid')
+            throw new Error('--classification must be superseded or invalid');
+        const result = await classifyFailedTask(store, job.id, id, { kind, targetTaskId: arg(args, '--target-task-id'), evidence: await textOption(args, '--evidence', '--evidence-file'), reason: await textOption(args, '--reason', '--reason-file') });
+        await saveLocal(localFile, result.job);
+        console.log(JSON.stringify(result.task, null, 2));
+        return;
+    }
     if (action === 'unblock') {
         await runTaskUnblockCommand(args, store, job, task, localFile);
         return;
@@ -798,7 +807,8 @@ async function main() {
             throw new Error(`${command} requires --repo and --id`);
         if (command === 'plan') {
             const guidance = hasArg(args, '--prompt') || hasArg(args, '--prompt-file') ? await textOption(args, '--prompt', '--prompt-file') : undefined;
-            console.log(JSON.stringify(await relayControlCommand(args, { command: 'job.plan', jobId, ...(guidance?.trim() ? { guidance: guidance.trim() } : {}) }), null, 2));
+            const cleanHistory = await cleanHistoryOption(args);
+            console.log(JSON.stringify(await relayControlCommand(args, { command: 'job.plan', jobId, ...(guidance?.trim() ? { guidance: guidance.trim() } : {}), ...(cleanHistory ? { cleanHistory } : {}) }), null, 2));
             return;
         }
         if (command === 'reconcile') {
@@ -824,10 +834,11 @@ async function main() {
     const { store, job, localFile } = loaded;
     if (command === 'plan') {
         const guidance = hasArg(args, '--prompt') || hasArg(args, '--prompt-file') ? await textOption(args, '--prompt', '--prompt-file') : undefined;
+        const cleanHistory = await cleanHistoryOption(args);
         await withEventBus(args, async (bus) => {
             const reconciler = runtime(store, args, bus);
             try {
-                const result = await reconciler.planJob(job.id, guidance?.trim() || undefined);
+                const result = await reconciler.planJob(job.id, guidance?.trim() || undefined, cleanHistory);
                 await saveLocal(localFile, result.job);
                 await publishWake(bus, result.job, result.round.id, `Planning round ${result.round.id} completed`);
                 console.log(JSON.stringify(result.round, null, 2));

package/dist/dashboard-actions.js

@@ -1,5 +1,5 @@
-import { applyJobGraphTarget, applyTaskGraphTarget } from './workflow/runtime.js';
-import { jobLifecycleV2, taskLifecycleV2 } from './workflow/definitions-v2.js';
+import { applyJobGraphTarget } from './workflow/runtime.js';
+import { jobLifecycleV2 } from './workflow/definitions-v2.js';
 import { dispatchWorkflowTargetOverride } from './workflow/dispatcher.js';
 import { dispatchTaskAction } from './task-actions.js';
 import { applyJobCancelAction } from './job-actions.js';
@@ -45,22 +45,12 @@ export function dashboardTaskSetState(store) {
             throw new Error(`Task ${taskId} not found`);
         if (task.state === state)
             return job;
-        if (task.state === 'BLOCKED' && state !== 'CANCELLED')
-            throw new Error(`Task ${task.id} is BLOCKED; only authoritative unblock may resume it`);
-        const now = new Date().toISOString();
-        const from = task.state;
-        await dispatchWorkflowTargetOverride(taskLifecycleV2, {
-            currentState: from, targetState: state, kind: 'task',
-            persistTransition: (_source, target) => { applyTaskGraphTarget(task, target, now); },
-        });
-        task.manualStateOverrides = [
-            ...(task.manualStateOverrides ?? []),
-            { from, to: state, at: now, actor: 'dashboard-user' },
-        ].slice(-20);
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.executionId = null;
-        await store.saveTask(task);
-        return await store.load(job.id);
+        if (state !== 'CANCELLED')
+            throw new Error('Task lifecycle state is managed by Relay; use retry, cancel, or the Troubleshooter response flow');
+        if (task.state !== 'CANCELLED') {
+            await dispatchTaskAction(store, { id: 'task.cancel', jobId, taskId });
+            return await store.load(job.id);
+        }
+        return job;
     };
 }

package/dist/dashboard-data.js

@@ -0,0 +1,45 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { eventsBusHistory } from './events-bus-runtime.js';
+const repositoryPattern = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
+const workflowDirectory = fileURLToPath(new URL('../workflow/', import.meta.url));
+export async function dashboardWorkflowGraphs() {
+    const names = (await readdir(workflowDirectory)).filter(name => name.endsWith('.mmd')).sort();
+    return Promise.all(names.map(async (name) => {
+        const source = await readFile(join(workflowDirectory, name), 'utf8');
+        const metadata = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(source)?.[1] ?? '';
+        const field = (key) => metadata.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))?.[1]?.trim() ?? '';
+        return {
+            id: name.replace(/\.mmd$/, ''),
+            name: field('title') || (name === 'main.mmd' ? 'Main / Happy Path' : name.replace(/\.mmd$/, '').split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join(' ')),
+            description: field('description'), path: `workflow/${name}`, source,
+        };
+    }));
+}
+export function githubPrUrl(repository, prNumber) {
+    if (typeof repository !== 'string' || typeof prNumber !== 'number' || !Number.isInteger(prNumber) || prNumber <= 0)
+        return null;
+    const match = repositoryPattern.exec(repository);
+    if (!match)
+        return null;
+    const [, owner, repo] = match;
+    if ([owner, repo].some(segment => segment === '.' || segment === '..'))
+        return null;
+    return `https://github.com/${owner}/${repo}/pull/${prNumber}`;
+}
+export function effectiveGitHubUsage(snapshot, runtime) {
+    const candidates = [snapshot?.resources.core, snapshot?.resources.graphql, snapshot?.resources.search, runtime?.resources.core, runtime?.resources.graphql, runtime?.resources.search]
+        .filter((candidate) => candidate !== undefined && candidate !== null)
+        .filter(candidate => Number.isFinite(candidate.limit) && Number(candidate.limit) > 0 && Number.isFinite(candidate.remaining) && Number.isFinite(candidate.reset));
+    const lowest = candidates.reduce((current, candidate) => !current || Number(candidate.remaining) / Number(candidate.limit) < Number(current.remaining) / Number(current.limit) ? candidate : current, null);
+    return lowest ? { limit: Number(lowest.limit), remaining: Number(lowest.remaining), reset: Number(lowest.reset) } : null;
+}
+export async function eventHistory(jobId, taskId, limit) {
+    try {
+        return await eventsBusHistory(jobId, taskId, limit);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/dashboard-html.js

@@ -263,7 +263,7 @@ const TASK_STATES=['DRAFT','QUEUED','RUNNING','BLOCKED','SUCCEEDED','FAILED','CA
 async function setTaskState(task,state,select){const job=selected();if(!job||state===task.state)return;select.disabled=true;try{const params=new URLSearchParams({id:job.id,task:task.id,state,repo:job.repository,pr:String(job.prNumber)});const response=await fetch('/api/task-state?'+params.toString(),{method:'POST'});if(!response.ok)throw new Error(response.status+' '+response.statusText);const updated=await response.json();const index=jobs.findIndex(candidate=>jobSelectionKey(candidate)===jobSelectionKey(job));if(index>=0)jobs[index]=updated;else jobs.push(updated);renderAll();void loadEventHistory();}catch(error){select.title='Set task state: '+error.message;select.value=task.state;}finally{select.disabled=false;}}
 function taskStateField(task){const box=element('div','detail-group');box.append(element('p','detail-label',text('State')));const select=document.createElement('select');select.className='job-filter task-state-select';select.setAttribute('aria-label','Task state');for(const state of TASK_STATES)select.append(new Option(state,state));select.value=task.state;select.addEventListener('change',()=>void setTaskState(task,select.value,select));box.append(select);return box;}
 function manualOverrideField(task){const rows=Array.isArray(task.manualStateOverrides)?task.manualStateOverrides:[];const last=rows.at(-1);return field('Manual override',last?last.from+' → '+last.to+' · '+relativeTime(last.at):'—');}
-function showDetailsDialog(title,sections){const dialog=element('dialog','details-dialog');dialog.setAttribute('aria-label',title);const head=element('div','details-dialog-head');const name=element('strong','',text(title));const close=element('button','refresh-button',text('Close'));close.type='button';close.addEventListener('click',()=>dialog.close());head.append(name,close);dialog.append(head);for(const [label,value] of sections){if(value===undefined||value===null||value==='')continue;dialog.append(element('h3','',text(label)));const content=element('pre');content.textContent=typeof value==='string'?value:JSON.stringify(value,null,2);dialog.append(content);}dialog.addEventListener('close',()=>dialog.remove());document.body.append(dialog);dialog.showModal();}function openJobDetails(){const job=selected();if(!job)return;showDetailsDialog('Job '+job.id+' · '+value(job.title),[['Objective',job.objective],['Description',job.description],['State',job.state],['Plans',job.plans?.map(p=>({id:p.id,status:p.status,assessment:p.assessment,error:p.error,generatedTaskIds:p.generatedTaskIds}))],['Review',job.review],['Outcome',job.result],['Publication',job.publication],['Failure',job.error]]);}function openTaskDetails(task){const result=task.result?.data??task.result;showDetailsDialog('Task '+task.id+' · '+value(task.title),[['Input / task objective',task.input],['State',task.state],['Conclusion',result],['Result summary',task.result?.summary],['Planner assessment',task.plannerResult?.assessment],['Resolution',task.resolution],['Failure',task.failureReason||task.error],['Dependencies',task.dependencies]]);}document.querySelector('#job-content-open').addEventListener('click',openJobDetails);function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Title',task.title||'—'),field('Task ID',task.id),field('Kind',task.kind||'work'),taskStateField(task),manualOverrideField(task),field('Planning decision',task.planningDecisionId||'—'),field('Planning source',task.planningSource||'—'),field('Planning round',task.planningRound===undefined?'—':String(task.planningRound)),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),taskCommentField(task),chatField(task));const job=selected();if(task.reviewHeadSha&&job)groups.append(commitField('HEAD commit',job,task.reviewHeadSha));const graph=agentGraphField(task);if(graph)groups.append(graph);if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));const result=task.result?.data??task.result;if(result){groups.append(field('Conclusion',result.verdict||result.outcome?.verdict||task.result?.summary||'Available'));}taskDetailRoot.append(groups);const details=element('button','refresh-button',text('Task details / conclusion'));details.type='button';details.addEventListener('click',()=>openTaskDetails(task));taskDetailRoot.append(details);}
+function showDetailsDialog(title,sections){const dialog=element('dialog','details-dialog');dialog.setAttribute('aria-label',title);const head=element('div','details-dialog-head');const name=element('strong','',text(title));const close=element('button','refresh-button',text('Close'));close.type='button';close.addEventListener('click',()=>dialog.close());head.append(name,close);dialog.append(head);for(const [label,value] of sections){if(value===undefined||value===null||value==='')continue;dialog.append(element('h3','',text(label)));const content=element('pre');content.textContent=typeof value==='string'?value:JSON.stringify(value,null,2);dialog.append(content);}dialog.addEventListener('close',()=>dialog.remove());document.body.append(dialog);dialog.showModal();}function openJobDetails(){const job=selected();if(!job)return;showDetailsDialog('Job '+job.id+' · '+value(job.title),[['Objective',job.objective],['Description',job.description],['State',job.state],['Plans',job.plans?.map(p=>({id:p.id,status:p.status,assessment:p.assessment,error:p.error,generatedTaskIds:p.generatedTaskIds}))],['Review',job.review],['Outcome',job.result],['Publication',job.publication],['Failure',job.error]]);}function openTaskDetails(task){const result=task.result?.data??task.result;showDetailsDialog('Task '+task.id+' · '+value(task.title),[['Input / task objective',task.input],['State',task.state],['Conclusion',result],['Result summary',task.result?.summary],['Planner assessment',task.plannerResult?.assessment],['Resolution',task.resolution],['Resolution classification',task.resolutionClassification],['Failure',task.failureReason||task.error],['Dependencies',task.dependencies]]);}document.querySelector('#job-content-open').addEventListener('click',openJobDetails);function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Title',task.title||'—'),field('Task ID',task.id),field('Kind',task.kind||'work'),taskStateField(task),manualOverrideField(task),field('Planning decision',task.planningDecisionId||'—'),field('Planning source',task.planningSource||'—'),field('Planning round',task.planningRound===undefined?'—':String(task.planningRound)),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),...(task.resolutionClassification?[field('Resolution classification',task.resolutionClassification.kind),field('Resolution target',task.resolutionClassification.targetTaskId),field('Resolution evidence',task.resolutionClassification.evidence),field('Resolution reason',task.resolutionClassification.reason)]:[]),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),taskCommentField(task),chatField(task));const job=selected();if(task.reviewHeadSha&&job)groups.append(commitField('HEAD commit',job,task.reviewHeadSha));const graph=agentGraphField(task);if(graph)groups.append(graph);if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));const result=task.result?.data??task.result;if(result){groups.append(field('Conclusion',result.verdict||result.outcome?.verdict||task.result?.summary||'Available'));}taskDetailRoot.append(groups);const details=element('button','refresh-button',text('Task details / conclusion'));details.type='button';details.addEventListener('click',()=>openTaskDetails(task));taskDetailRoot.append(details);}
 function reviewStatus(job){const review=job?.review;if(!review)return 'Not started';if(review.outcome==='approved'&&review.headSha===job.headSha)return 'MERGE READY · approved';const stale=Array.isArray(job?.tasks)&&job.tasks.some(task=>task.agentName==='reviewer'&&task.reviewHeadSha&&job.headSha&&task.reviewHeadSha!==job.headSha);if(stale)return 'STALE · awaiting review';return String(review.outcome||'pending').replace('_',' ').toUpperCase();}function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent=value(job.title||job.id);if(jobSelectionKey(job)!==selectedJob){selectedJob=jobSelectionKey(job);selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}const summary=element('div','job-summary');summary.append(field('PR state',job.githubState||'UNKNOWN'),jobStateField(job),field('Runtime status',job.runtimeStatus||'IDLE'),field('Execution mode',job.executionMode||'fixed'),field('Cadence',cadence(job)),field('Review',reviewStatus(job)),field('Creator thread',job.creatorThreadId||'—'),threadField('Implementation thread',job.implementationThreadId),threadField('Reviewer thread',job.reviewerThreadId),commitField('Review head SHA',job,job.review?.headSha||job.headSha||''),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(job.tasks)),chatShortcutField(job));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;eventTaskId=null;clearEvents();rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);renderEventScope();}function renderAll(){jobs.sort(compareJobs);syncFilters();renderJobList();renderSelectedJob();syncMobileJobsView();}
 function isCompleteUnmerged(job){return job.runtimeStatus==='MERGE_PENDING';}
 function isTerminalJob(job){return ['COMPLETED','CANCELLED'].includes(job.state)||['MERGED','CLOSED'].includes(job.githubState);}

package/dist/dashboard.js

@@ -2,67 +2,17 @@ import { inspectWorkflowSymbol } from './dashboard-workflow-inspection.js';
 import { createServer } from 'node:http';
 import { subscribeLocalCommits } from './local-commit-events.js';
 import { handleTroubleshooterQa } from './troubleshooter-qa-api.js';
-import { readFile, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { readUsageSnapshot } from './usage.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
 import { loadExecutionRouterRules, saveExecutionRouterRules } from './routing-policy.js';
 import { summarizeRuntime } from './runtime-summary.js';
-import { eventsBusHistory } from './events-bus-runtime.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})$/;
+import { dashboardWorkflowGraphs, effectiveGitHubUsage, eventHistory } from './dashboard-data.js';
+export { dashboardWorkflowGraphs, githubPrUrl } from './dashboard-data.js';
 const SSE_HEARTBEAT_MS = 15000;
-const WORKFLOW_DIR = fileURLToPath(new URL('../workflow/', import.meta.url));
-export async function dashboardWorkflowGraphs() {
-    const names = (await readdir(WORKFLOW_DIR)).filter(name => name.endsWith('.mmd')).sort();
-    return Promise.all(names.map(async (name) => {
-        const source = await readFile(join(WORKFLOW_DIR, name), 'utf8');
-        const metadata = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(source)?.[1] ?? '';
-        const field = (key) => metadata.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))?.[1]?.trim() ?? '';
-        return {
-            id: name.replace(/\.mmd$/, ''),
-            name: field('title') || (name === 'main.mmd' ? 'Main / Happy Path' : name.replace(/\.mmd$/, '').split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join(' ')),
-            description: field('description'),
-            path: `workflow/${name}`, source,
-        };
-    }));
-}
-function effectiveGitHubUsage(snapshot, runtime) {
-    const candidates = [snapshot?.resources.core, snapshot?.resources.graphql, snapshot?.resources.search, runtime?.resources.core, runtime?.resources.graphql, runtime?.resources.search]
-        .filter((candidate) => candidate !== undefined && candidate !== null)
-        .filter(candidate => Number.isFinite(candidate.limit) && Number(candidate.limit) > 0 && Number.isFinite(candidate.remaining) && Number.isFinite(candidate.reset));
-    const lowest = candidates.reduce((current, candidate) => !current || Number(candidate.remaining) / Number(candidate.limit) < Number(current.remaining) / Number(current.limit) ? candidate : current, null);
-    return lowest ? { limit: Number(lowest.limit), remaining: Number(lowest.remaining), reset: Number(lowest.reset) } : null;
-}
-function isPositiveInteger(candidate) {
-    return typeof candidate === 'number' && Number.isInteger(candidate) && candidate > 0;
-}
 function isTaskId(candidate) {
     return candidate.length > 0;
 }
-function isSafeRepositorySegment(segment) {
-    return segment !== '.' && segment !== '..';
-}
-export function githubPrUrl(repository, prNumber) {
-    if (typeof repository !== 'string' || !isPositiveInteger(prNumber))
-        return null;
-    const match = GITHUB_REPOSITORY_PATTERN.exec(repository);
-    if (!match)
-        return null;
-    const [, owner, repo] = match;
-    if (!isSafeRepositorySegment(owner) || !isSafeRepositorySegment(repo))
-        return null;
-    return `https://github.com/${owner}/${repo}/pull/${prNumber}`;
-}
-async function eventHistory(jobId, taskId, limit) {
-    try {
-        return await eventsBusHistory(jobId, taskId, limit);
-    }
-    catch {
-        return [];
-    }
-}
 export { dashboardHtml, dashboardVersion, dashboardSourceRevision } from './dashboard-html.js';
 import { dashboardHtml, dashboardVersion } from './dashboard-html.js';
 export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobId, usageRegistry, overviewProvider, webhook, statusProvider, githubUsageProvider, exactJobProvider, actions, routerTestProvider, decisionAuditProvider) {

package/dist/host-invocation-store.js

@@ -51,8 +51,8 @@ export function recordHostInvocationDecision(db, delivery, fingerprint, writeSna
         const job = snapshot?.json ? JSON.parse(snapshot.json) : null;
         const task = job?.tasks.find(item => item.id === delivery.taskId);
         const invocation = task?.interactiveInvocation;
-        if (!job || !task || !invocation || !(['RUNNING', 'BLOCKED'].includes(task.state)) || invocation.executionId !== delivery.executionId ||
-            (task.executionId !== delivery.executionId && task.state !== 'BLOCKED') ||
+        if (!job || !task || !invocation || !(['RUNNING', 'DRAFT'].includes(task.state)) || invocation.executionId !== delivery.executionId ||
+            (task.executionId !== delivery.executionId && task.state !== 'DRAFT') ||
             invocation.status !== 'awaiting_decision' || invocation.invocationId !== delivery.invocationId || invocation.revision !== delivery.revision) {
             recordHostInvocationEvent(db, delivery, 'stale', fingerprint);
             db.exec('COMMIT');

package/dist/interactive-invocation.js

@@ -167,7 +167,7 @@ export class HostInteractiveInvocationCoordinator {
         const job = await this.options.store.loadJob(delivery.jobId);
         const task = job?.tasks.find((item) => item.id === delivery.taskId);
         if (!job || !task || task.interactiveInvocation?.executionId !== delivery.executionId ||
-            (task.executionId !== delivery.executionId && task.state !== 'BLOCKED')) {
+            (task.executionId !== delivery.executionId && task.state !== 'DRAFT')) {
             await this.options.store.recordHostInvocationEvent?.(delivery, 'stale', interactiveDecisionFingerprint(delivery));
             return { outcome: 'stale', reason: 'execution_not_bound' };
         }

package/dist/interactive-resume.js

@@ -8,13 +8,13 @@ export async function resumeInteractiveTask(store, jobId, taskId, invocationId,
     await store.mutateJob(jobId, job => {
         const task = job.tasks.find(item => item.id === taskId);
         const invocation = task?.interactiveInvocation;
-        if (!task || task.state !== 'BLOCKED' || !invocation ||
+        if (!task || task.state !== 'DRAFT' || !invocation ||
             invocation.invocationId !== invocationId || invocation.revision !== revision ||
             invocation.status !== decision || !invocation.decidedAt)
             return job;
-        // Both state transitions and retry eligibility are owned by task-lifecycle.mmd.
-        if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted) {
-            throw new Error('Interactive Task unblock rejected by canonical lifecycle Graph');
+        // Accepted interactive decisions release the same waiting Task from DRAFT.
+        if (!tryTransitionTaskEvent(task, 'release').accepted) {
+            throw new Error('Interactive Task release rejected by canonical lifecycle Graph');
         }
         applyTaskUnblockRetrySnapshot(task);
         task.error = null;
@@ -30,7 +30,7 @@ export async function recoverInteractiveDecisions(store, jobId) {
     const job = await store.load(jobId);
     let recovered = false;
     for (const task of job.tasks) {
-        if (task.state !== 'BLOCKED' || !task.interactiveInvocation?.decidedAt)
+        if (task.state !== 'DRAFT' || !task.interactiveInvocation?.decidedAt)
             continue;
         const invocation = task.interactiveInvocation;
         if (invocation.status === 'awaiting_decision' || !await shouldRecoverInteractiveDecision(invocation.status))

package/dist/legacy-blocked-task-migration.js

@@ -0,0 +1,14 @@
+import { normalizeLegacyTaskLifecycle } from './types.js';
+/** Move pre-contract ordinary BLOCKED snapshots to FAILED without touching the
+ * independent append-only event history. Unknown execution evidence is kept. */
+export function migrateLegacyBlockedTasks(db) {
+    const rows = db.prepare('SELECT job_id,json FROM job_snapshot').all();
+    const update = db.prepare('UPDATE job_snapshot SET json=? WHERE job_id=?');
+    for (const row of rows) {
+        const job = JSON.parse(row.json);
+        const before = JSON.stringify(job.tasks);
+        job.tasks = job.tasks.map(task => normalizeLegacyTaskLifecycle(task, job.executionMode));
+        if (JSON.stringify(job.tasks) !== before)
+            update.run(JSON.stringify(job), row.job_id);
+    }
+}

package/dist/legacy-orchestrator-repair.js

@@ -6,7 +6,7 @@ export async function repairLegacyOrchestrators(jobId, now, ports) {
     const { store } = ports;
     const repairOne = async (taskId) => {
         if (store.mutateJob) {
-            let outcome = { repaired: false, externallyCompleted: false, blocked: false, ageMs: 0 };
+            let outcome = { repaired: false, externallyCompleted: false, failed: false, ageMs: 0 };
             return await store.mutateJob(jobId, current => {
                 const task = current.tasks.find(item => item.id === taskId);
                 if (!task)
@@ -40,12 +40,12 @@ export async function repairLegacyOrchestrators(jobId, now, ports) {
         const job = await store.load(jobId);
         const task = job.tasks.find(item => item.id === stale.id);
         const type = repair.externallyCompleted ? 'task.external_completion_applied'
-            : repair.blocked ? 'task.orchestrator_quarantined' : 'task.orchestrator_rescued';
-        const status = repair.externallyCompleted ? 'succeeded' : repair.blocked ? 'blocked' : 'queued';
+            : repair.failed ? 'task.orchestrator_quarantined' : 'task.orchestrator_rescued';
+        const status = repair.externallyCompleted ? 'succeeded' : repair.failed ? 'failed' : 'queued';
         await ports.emit(eventFor(job.id, task.id, task.parentTaskId, type, status, repair.externallyCompleted
             ? `Applied durable external completion for legacy orchestrator task ${task.id}`
-            : repair.blocked
-                ? `Quarantined legacy RUNNING orchestrator task ${task.id}; external outcome must be verified before replacement work`
-                : `Recovered legacy orchestrator task ${task.id} through Execution Router`, 'orchestrator', { ageMs: repair.ageMs, adapter: repair.externallyCompleted || repair.blocked ? undefined : 'execution-router' }, { agent: 'relay', component: 'agents-relay' }));
+            : repair.failed
+                ? `Failed legacy RUNNING orchestrator task ${task.id}; worker outcome is unknown and Troubleshooter diagnosis is required`
+                : `Recovered legacy orchestrator task ${task.id} through Execution Router`, 'orchestrator', { ageMs: repair.ageMs, adapter: repair.externallyCompleted || repair.failed ? undefined : 'execution-router' }, { agent: 'relay', component: 'agents-relay' }));
     }
 }

package/dist/manual-plan.js

@@ -1,7 +1,8 @@
 import { dispatchJobLifecycleSync } from './workflow/lifecycle.js';
 import { createPlanRound, pendingPlan } from './planner.js';
 import { applyJobActivateAction } from './job-actions.js';
-export async function executeManualPlan(store, jobId, guidance, timeoutMs, launchPlanner) {
+import { classifyTaskResolution } from './workflow/task-resolution.js';
+export async function executeManualPlan(store, jobId, guidance, timeoutMs, launchPlanner, cleanHistory) {
     let job = await store.load(jobId);
     if (['COMPLETED', 'CANCELLED'].includes(job.state))
         throw new Error(`Cannot plan terminal job ${job.id} (${job.state})`);
@@ -18,6 +19,23 @@ export async function executeManualPlan(store, jobId, guidance, timeoutMs, launc
             if (current.pause)
                 throw new Error(`Cannot plan paused Job ${current.id}; resume it first`);
             const concurrent = pendingPlan(current);
+            if (cleanHistory) {
+                if (concurrent)
+                    throw new Error(`--force-clean-history requires no pending Plan (${concurrent.id})`);
+                const failed = current.tasks.filter(task => task.kind !== 'planner' && task.state === 'FAILED' && !task.resolutionClassification);
+                const provided = new Map(cleanHistory.map(item => [item.taskId, item]));
+                if (provided.size !== cleanHistory.length || failed.length !== provided.size || failed.some(task => !provided.has(task.id)))
+                    throw new Error('--force-clean-history requires exactly one explicit classification for every FAILED work Task');
+                for (const task of failed) {
+                    const item = provided.get(task.id);
+                    if (item.targetTaskId === task.id || !current.tasks.some(target => target.id === item.targetTaskId))
+                        throw new Error(`Classification for ${task.id} must target a different durable Task in this Job`);
+                    classifyTaskResolution(task, item);
+                }
+                const unknown = current.tasks.filter(task => task.kind !== 'planner' && task.state === 'FAILED' && task.failureReason === 'worker_outcome_unknown');
+                if (unknown.length)
+                    throw new Error(`--force-clean-history cannot proceed while FAILED Task execution outcomes are unknown: ${unknown.map(task => task.id).join(', ')}`);
+            }
             if (concurrent) {
                 if (concurrent.executionId)
                     throw new Error(`Planning round ${concurrent.id} is already PLANNING`);