agents-relay 2.0.211 → 2.0.212
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/dashboard-html.js +2 -2
- package/dist/dashboard-style.js +1 -1
- package/dist/dashboard.js +1 -1
- package/dist/host-invocation-store.js +3 -3
- package/dist/interactive-invocation.js +1 -1
- package/dist/interactive-resume.js +4 -4
- package/dist/job-execution-slot.js +1 -1
- package/dist/local-authority-store.js +1 -1
- package/dist/reconciler-runtime.js +12 -10
- package/dist/runtime-status.js +1 -1
- package/dist/shortcut-worker-runner.js +1 -1
- package/dist/types.js +9 -0
- package/dist/workflow/contracts.js +2 -2
- package/dist/workflow/definitions-v2.js +1 -1
- package/dist/workflow/planner-orchestration-v2.js +1 -1
- package/package.json +1 -1
- package/skills/agents-relay/contracts/event-contract.md +18 -0
- package/workflow/task-lifecycle.mmd +5 -2
package/README.md
CHANGED
|
@@ -87,7 +87,7 @@ npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1
|
|
|
87
87
|
npx agents-relay job show --repo OWNER/REPO --pr 12 --id job-1
|
|
88
88
|
~~~
|
|
89
89
|
|
|
90
|
-
Task readiness is explicit: `DRAFT` means the durable task exists but is not executable yet; `QUEUED` means Relay may execute it now; `RUNNING` means worker execution has started. Tasks created with dependencies start `DRAFT` and become `QUEUED` when those dependencies succeed. A dependency-free task created with `--draft` stays held until `task update --queue`.
|
|
90
|
+
Task readiness is explicit: `DRAFT` means the durable task exists but is not executable yet; `QUEUED` means Relay may execute it now; `RUNNING` means worker execution has started. Tasks created with dependencies start `DRAFT` and become `QUEUED` when those dependencies succeed. A dependency-free task created with `--draft` stays held until `task update --queue`. After binding an interactive request, a running Task may enter `AWAITING_DECISION` and release its Worker. Approved or changes-requested decisions requeue the same Task; `BLOCKED` is reserved for Troubleshooter escalation. Ordinary `DRAFT` Tasks remain unstarted/dependency-held.
|
|
91
91
|
|
|
92
92
|
Mutable draft/queued/retryable task fields can be changed in place without replacing the durable task identity. `task update` rejects `RUNNING`, `SUCCEEDED`, and `CANCELLED` tasks so active execution and terminal history cannot be rewritten. For example:
|
|
93
93
|
|
package/dist/dashboard-html.js
CHANGED
|
@@ -203,7 +203,7 @@ function shortManagedId(id,repository,kind){const parts=String(repository||'').s
|
|
|
203
203
|
function jobForSelection(selection){return jobs.find(job=>jobSelectionKey(job)===selection)||jobs.find(job=>job.id===selection)||null;}
|
|
204
204
|
function selected(){return jobForSelection(selectedJob)||jobs[0]||null;}
|
|
205
205
|
function counts(tasks){const out={};for(const task of Array.isArray(tasks)?tasks:[])out[task.state]=(out[task.state]||0)+1;return out;}
|
|
206
|
-
function compactCounts(input){const order=['RUNNING','BLOCKED','FAILED','QUEUED','DRAFT','SUCCEEDED','CANCELLED'];return order.filter(state=>input[state]).map(state=>input[state]+' '+state).join(', ')||'No tasks';}
|
|
206
|
+
function compactCounts(input){const order=['RUNNING','AWAITING_DECISION','BLOCKED','FAILED','QUEUED','DRAFT','SUCCEEDED','CANCELLED'];return order.filter(state=>input[state]).map(state=>input[state]+' '+state).join(', ')||'No tasks';}
|
|
207
207
|
function relativeTime(timestamp){if(!timestamp)return '—';const parsed=Date.parse(timestamp);if(!Number.isFinite(parsed))return value(timestamp);const seconds=Math.max(0,Math.round((Date.now()-parsed)/1000));if(seconds<60)return 'just now';if(seconds<3600)return Math.floor(seconds/60)+'m ago';if(seconds<86400)return Math.floor(seconds/3600)+'h ago';return Math.floor(seconds/86400)+'d ago';}
|
|
208
208
|
function safePrUrl(repository,prNumber){if(typeof repository!=='string'||!Number.isInteger(prNumber)||prNumber<=0)return null;const parts=repository.split('/');if(parts.length!==2)return null;const [owner,repo]=parts;if(!owner||!repo||owner==='.'||owner==='..'||repo==='.'||repo==='..')return null;if(!/^[A-Za-z0-9-]+$/.test(owner)||!/^[A-Za-z0-9._-]+$/.test(repo))return null;return 'https://github.com/'+owner+'/'+repo+'/pull/'+prNumber;}
|
|
209
209
|
function safeCommitUrl(repository,sha){if(typeof repository!=='string'||typeof sha!=='string'||!/^[0-9a-f]{7,64}$/i.test(sha))return null;const parts=repository.split('/');if(parts.length!==2||!parts[0]||!parts[1])return null;return 'https://github.com/'+parts[0]+'/'+parts[1]+'/commit/'+sha;}
|
|
@@ -254,7 +254,7 @@ function attemptBudget(task){const attempt=Number(task?.attempt)||0;const max=Nu
|
|
|
254
254
|
const JOB_STATES=['DRAFT','ACTIVE','COMPLETED','CANCELLED'];
|
|
255
255
|
async function setJobState(job,state,select){if(!job||state===job.state)return;select.disabled=true;try{const params=new URLSearchParams({id:job.id,state,repo:job.repository,pr:String(job.prNumber)});const response=await fetch('/api/job-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 job lifecycle state: '+error.message;select.value=job.state;}finally{select.disabled=false;}}
|
|
256
256
|
function jobStateField(job){const box=element('div','detail-group');box.append(element('p','detail-label',text('Lifecycle state')));const select=document.createElement('select');select.className='job-filter job-state-select';select.dataset.state=job.state;select.setAttribute('aria-label','Job lifecycle state');for(const state of JOB_STATES)select.append(new Option(state,state));select.value=job.state;select.addEventListener('change',()=>void setJobState(job,select.value,select));box.append(select);return box;}
|
|
257
|
-
const TASK_STATES=['DRAFT','QUEUED','RUNNING','BLOCKED','SUCCEEDED','FAILED','CANCELLED'];
|
|
257
|
+
const TASK_STATES=['DRAFT','QUEUED','RUNNING','AWAITING_DECISION','BLOCKED','SUCCEEDED','FAILED','CANCELLED'];
|
|
258
258
|
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;}}
|
|
259
259
|
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;}
|
|
260
260
|
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):'—');}
|
package/dist/dashboard-style.js
CHANGED
|
@@ -77,7 +77,7 @@ export const dashboardStyles = ` <style>
|
|
|
77
77
|
.job-status-line .badge { flex:0 0 auto; }
|
|
78
78
|
.status-pill,.badge { display:inline-flex; align-items:center; border-radius:999px; padding:.06rem .42rem; min-height:1.35rem; font-size:.68rem; font-weight:800; }
|
|
79
79
|
.status-pill.ok,.badge.ACTIVE,.badge.RUNNING,.badge.SUCCEEDED,.badge.COMPLETED,.badge.MERGED { background:#e5f3e9; color:var(--ok); }
|
|
80
|
-
.status-pill.warn,.badge.BLOCKED,.badge.DRAFT,.badge.QUEUED,.badge.WAITING,.badge.OPEN { background:#fff1d2; color:var(--warn); }
|
|
80
|
+
.status-pill.warn,.badge.BLOCKED,.badge.DRAFT,.badge.QUEUED,.badge.WAITING,.badge.AWAITING_DECISION,.badge.OPEN { background:#fff1d2; color:var(--warn); }
|
|
81
81
|
.status-pill.bad,.badge.FAILED { background:#ffe8e8; color:var(--bad); }
|
|
82
82
|
.status-pill.neutral,.badge.IDLE,.badge.CANCELLED { background:#edf0f4; color:var(--muted); }
|
|
83
83
|
.badge.DRAFT { background:#eef2ff; color:#3f51b5; }
|
package/dist/dashboard.js
CHANGED
|
@@ -374,7 +374,7 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
|
|
|
374
374
|
const repository = url.searchParams.get('repo') ?? undefined;
|
|
375
375
|
const parsedPr = Number(url.searchParams.get('pr'));
|
|
376
376
|
const prNumber = Number.isInteger(parsedPr) && parsedPr > 0 ? parsedPr : undefined;
|
|
377
|
-
const validState = ['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'].includes(requestedState);
|
|
377
|
+
const validState = ['DRAFT', 'QUEUED', 'RUNNING', 'AWAITING_DECISION', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'].includes(requestedState);
|
|
378
378
|
if (req.method !== 'POST' || !/^[A-Za-z0-9_.-]+$/.test(requestedJobId) || !isTaskId(requestedTaskId) || !validState || !resolvedActions?.taskSetState) {
|
|
379
379
|
res.writeHead(404);
|
|
380
380
|
res.end('Task state override unavailable');
|
|
@@ -52,13 +52,13 @@ export function recordHostInvocationDecision(db, delivery, fingerprint, writeSna
|
|
|
52
52
|
const job = snapshot?.json ? JSON.parse(snapshot.json) : null;
|
|
53
53
|
const task = job?.tasks.find(item => item.id === delivery.taskId);
|
|
54
54
|
const invocation = task?.interactiveInvocation;
|
|
55
|
-
const bound = invocation && ['RUNNING', '
|
|
55
|
+
const bound = invocation && ['RUNNING', 'AWAITING_DECISION'].includes(task?.state ?? '') &&
|
|
56
56
|
invocation.executionId === delivery.executionId &&
|
|
57
|
-
(task?.executionId === delivery.executionId || task?.state === '
|
|
57
|
+
(task?.executionId === delivery.executionId || task?.state === 'AWAITING_DECISION') &&
|
|
58
58
|
invocation.status === 'awaiting_decision' && invocation.invocationId === delivery.invocationId &&
|
|
59
59
|
invocation.revision === delivery.revision;
|
|
60
60
|
// Event-only reviews are claims against an ACTIVE execution, not permission to
|
|
61
|
-
// release an arbitrary
|
|
61
|
+
// release an arbitrary waiting/failed/cancelled Task or replay an older revision.
|
|
62
62
|
const active = job?.state === 'ACTIVE' && task?.state === 'RUNNING' &&
|
|
63
63
|
task.executionId === delivery.executionId && eventOnlyReviewEligible(delivery);
|
|
64
64
|
const seen = db.prepare('SELECT 1 FROM host_invocation_decision WHERE job_id=? AND task_id=? AND execution_id=? AND revision=?')
|
|
@@ -199,7 +199,7 @@ export class HostInteractiveInvocationCoordinator {
|
|
|
199
199
|
const job = await this.options.store.loadJob(delivery.jobId);
|
|
200
200
|
const task = job?.tasks.find((item) => item.id === delivery.taskId);
|
|
201
201
|
if (!job || !task ||
|
|
202
|
-
(task.executionId !== delivery.executionId && task.state !== '
|
|
202
|
+
(task.executionId !== delivery.executionId && task.state !== 'AWAITING_DECISION')) {
|
|
203
203
|
await this.options.store.recordHostInvocationEvent?.(delivery, 'stale', interactiveDecisionFingerprint(delivery));
|
|
204
204
|
return { outcome: 'stale', reason: 'execution_not_bound' };
|
|
205
205
|
}
|
|
@@ -8,12 +8,12 @@ export async function resumeInteractiveTask(store, jobId, taskId, invocationId,
|
|
|
8
8
|
await store.mutateJob(jobId, job => {
|
|
9
9
|
const task = job.tasks.find(item => item.id === taskId);
|
|
10
10
|
const invocation = task?.interactiveInvocation;
|
|
11
|
-
if (!task || task.state !== '
|
|
11
|
+
if (!task || task.state !== 'AWAITING_DECISION' || !invocation ||
|
|
12
12
|
invocation.invocationId !== invocationId || invocation.revision !== revision ||
|
|
13
13
|
invocation.status !== decision || !invocation.decidedAt)
|
|
14
14
|
return job;
|
|
15
|
-
// Accepted interactive decisions
|
|
16
|
-
if (!tryTransitionTaskEvent(task, '
|
|
15
|
+
// Accepted interactive decisions requeue the same waiting Task through the canonical Graph.
|
|
16
|
+
if (!tryTransitionTaskEvent(task, 'interactive.resume').accepted) {
|
|
17
17
|
throw new Error('Interactive Task release rejected by canonical lifecycle Graph');
|
|
18
18
|
}
|
|
19
19
|
applyTaskUnblockRetrySnapshot(task);
|
|
@@ -30,7 +30,7 @@ export async function recoverInteractiveDecisions(store, jobId) {
|
|
|
30
30
|
const job = await store.load(jobId);
|
|
31
31
|
let recovered = false;
|
|
32
32
|
for (const task of job.tasks) {
|
|
33
|
-
if (task.state !== '
|
|
33
|
+
if (task.state !== 'AWAITING_DECISION' || !task.interactiveInvocation?.decidedAt)
|
|
34
34
|
continue;
|
|
35
35
|
const invocation = task.interactiveInvocation;
|
|
36
36
|
if (invocation.status === 'awaiting_decision' || !await shouldRecoverInteractiveDecision(invocation.status))
|
|
@@ -15,7 +15,7 @@ export function jobHasActiveExecution(job, except = {}) {
|
|
|
15
15
|
&& task.leaseOwner === null && shortcut && typeof shortcut === 'object'
|
|
16
16
|
&& shortcut.waits
|
|
17
17
|
&& Object.keys(shortcut.waits).length > 0;
|
|
18
|
-
return !durableWait && !delegatedWorker && (task.state === 'RUNNING' || (task.executionId !== null && !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(task.state)));
|
|
18
|
+
return task.state !== 'AWAITING_DECISION' && !durableWait && !delegatedWorker && (task.state === 'RUNNING' || (task.executionId !== null && !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(task.state)));
|
|
19
19
|
});
|
|
20
20
|
const planner = (job.plans ?? []).some(plan => plan.id !== except.planId
|
|
21
21
|
&& plan.executionId !== null && plan.status === 'PLANNING');
|
|
@@ -12,7 +12,7 @@ import { publishLocalCommit } from './local-commit-events.js';
|
|
|
12
12
|
* not lifecycle storage. An explicit one-time import must use RelayStore directly.
|
|
13
13
|
*/
|
|
14
14
|
const TASK_STATE_ORDER = {
|
|
15
|
-
DRAFT: 0, QUEUED: 1, RUNNING: 2,
|
|
15
|
+
DRAFT: 0, QUEUED: 1, RUNNING: 2, AWAITING_DECISION: 3, BLOCKED: 4,
|
|
16
16
|
SUCCEEDED: 5, FAILED: 5, CANCELLED: 5,
|
|
17
17
|
};
|
|
18
18
|
export class LocalAuthorityDurableStore {
|
|
@@ -102,7 +102,7 @@ export class ReconcilerRuntimeBase {
|
|
|
102
102
|
if (normalized)
|
|
103
103
|
return normalized.type === 'task.failed' ? this.applyTerminalEvent(normalized) : this.applyReviewEvent(normalized);
|
|
104
104
|
}
|
|
105
|
-
if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
|
|
105
|
+
if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled', 'task.interactive_waiting'].includes(event.type)) {
|
|
106
106
|
const result = await this.applyTerminalEvent(event);
|
|
107
107
|
if (event.type !== 'task.failed' || event.source?.watchdog !== true || event.data?.workflowEvent !== 'watchdog.failed' || result.reconcile)
|
|
108
108
|
return result;
|
|
@@ -400,15 +400,17 @@ export class ReconcilerRuntimeBase {
|
|
|
400
400
|
}
|
|
401
401
|
const liveAtTerminal = this.live.get(event.task_id);
|
|
402
402
|
const terminalEventExecutionId = executionIdFromSource(eventSourceId(event), event.job_id, event.task_id);
|
|
403
|
-
const lifecycleEvent = event.type
|
|
404
|
-
? (await this.store.load(event.job_id)).tasks.find(task => task.id === event.task_id)?.interactiveInvocation?.status === 'awaiting_decision'
|
|
405
|
-
? 'interactive.waiting' : event.type
|
|
406
|
-
: event.type;
|
|
403
|
+
const lifecycleEvent = event.type;
|
|
407
404
|
const transition = await withExecutionBoundary(event.job_id, event.task_id, () => this.taskTransitions.apply(event.job_id, event.task_id, lifecycleEvent, {
|
|
408
405
|
eligible: (_job, task) => {
|
|
409
406
|
if (!['codex', 'chatgpt', 'z', 'orchestrator'].includes(task.adapter))
|
|
410
407
|
return false;
|
|
411
|
-
if (event.type === 'task.blocked' &&
|
|
408
|
+
if (event.type === 'task.blocked' && (!trustedInternal || task.agentName !== 'troubleshooter'))
|
|
409
|
+
return false;
|
|
410
|
+
if (event.type === 'task.interactive_waiting' &&
|
|
411
|
+
(task.interactiveInvocation?.status !== 'awaiting_decision' ||
|
|
412
|
+
task.interactiveInvocation.executionId !== task.executionId ||
|
|
413
|
+
!isCorrelatedWorkerEvent(task, event)))
|
|
412
414
|
return false;
|
|
413
415
|
if (isFinalReviewAgent(task.agentName) && event.type === 'task.completed')
|
|
414
416
|
return false;
|
|
@@ -427,7 +429,7 @@ export class ReconcilerRuntimeBase {
|
|
|
427
429
|
facts: (_job, task) => {
|
|
428
430
|
const processExitedAfterPublishedTerminal = task.failureReason === 'worker_exit_without_terminal_event';
|
|
429
431
|
const freshEnough = processExitedAfterPublishedTerminal || isCorrelatedWorkerEvent(task, event);
|
|
430
|
-
return { recoverableExecution: isRecoverableWatchdogFailure(task) && freshEnough, awaitingInteractiveDecision: lifecycleEvent === '
|
|
432
|
+
return { recoverableExecution: isRecoverableWatchdogFailure(task) && freshEnough, awaitingInteractiveDecision: lifecycleEvent === 'task.interactive_waiting' && task.interactiveInvocation?.status === 'awaiting_decision' };
|
|
431
433
|
},
|
|
432
434
|
mutate: (job, task) => {
|
|
433
435
|
const modelBacked = ['codex', 'chatgpt', 'z'].includes(task.adapter);
|
|
@@ -458,7 +460,7 @@ export class ReconcilerRuntimeBase {
|
|
|
458
460
|
task.error = event.message || `Task ${task.id} failed`;
|
|
459
461
|
task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
|
|
460
462
|
}
|
|
461
|
-
else if (event.type === 'task.blocked'
|
|
463
|
+
else if (event.type === 'task.blocked') {
|
|
462
464
|
task.error = event.message || `Task ${task.id} blocked`;
|
|
463
465
|
const data = event.data ?? {};
|
|
464
466
|
const head = ['candidate_head', 'candidate_head_sha', 'pr_head', 'head_sha']
|
|
@@ -478,7 +480,7 @@ export class ReconcilerRuntimeBase {
|
|
|
478
480
|
}));
|
|
479
481
|
if (!transition?.decision.accepted)
|
|
480
482
|
return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
|
|
481
|
-
if (lifecycleEvent !== '
|
|
483
|
+
if (lifecycleEvent !== 'task.interactive_waiting')
|
|
482
484
|
await recordTerminalRouteOutcome(this.options.decisionAuditStore, transition.task, event, terminalEventExecutionId ?? null);
|
|
483
485
|
if (transition.task.adapter === 'codex' && liveAtTerminal && !liveAtTerminal.processSettled && liveAtTerminal.jobId === event.job_id && (!terminalEventExecutionId || liveAtTerminal.executionId === terminalEventExecutionId)) {
|
|
484
486
|
liveAtTerminal.controller.abort();
|
|
@@ -487,7 +489,7 @@ export class ReconcilerRuntimeBase {
|
|
|
487
489
|
if (event.type === 'task.completed')
|
|
488
490
|
await this.deliverContinuation(transition.job, transition.task);
|
|
489
491
|
const reviewWorker = isFinalReviewAgent(transition.task.agentName);
|
|
490
|
-
return { applied: true, reconcile: lifecycleEvent !== '
|
|
492
|
+
return { applied: true, reconcile: lifecycleEvent !== 'task.interactive_waiting' && (!reviewWorker || event.type === 'task.failed'), reason: reviewWorker ? `${event.type}.review-worker` : event.type, reconcileMode: reviewWorker || lifecycleEvent === 'task.interactive_waiting' ? undefined : 'detached' };
|
|
491
493
|
}
|
|
492
494
|
terminalWait(taskId, executionId, launchBarrier) {
|
|
493
495
|
let resolve;
|
package/dist/runtime-status.js
CHANGED
|
@@ -61,7 +61,7 @@ export function deriveJobRuntimeStatus(job, _prState = 'OPEN') {
|
|
|
61
61
|
const staleRevisions = staleTargetedRevisionTaskIds(job);
|
|
62
62
|
if (job.tasks.some(task => task.state === 'FAILED' && !staleRevisions.has(task.id)))
|
|
63
63
|
return 'FAILED';
|
|
64
|
-
if (job.tasks.some(task => task.state === 'DRAFT'))
|
|
64
|
+
if (job.tasks.some(task => task.state === 'AWAITING_DECISION' || task.state === 'DRAFT'))
|
|
65
65
|
return 'WAITING';
|
|
66
66
|
if (plannerFailed)
|
|
67
67
|
return 'FAILED';
|
|
@@ -59,7 +59,7 @@ export async function driveShortcutWorkers(options) {
|
|
|
59
59
|
});
|
|
60
60
|
return { status: 'COMPLETED', job };
|
|
61
61
|
}
|
|
62
|
-
if (job.tasks.some(task => task.state === 'BLOCKED'))
|
|
62
|
+
if (job.tasks.some(task => task.state === 'BLOCKED' || task.state === 'AWAITING_DECISION'))
|
|
63
63
|
return { status: 'WAITING_EVENT', job };
|
|
64
64
|
if (job.tasks.some(task => task.agentName === 'troubleshooter' && task.state === 'FAILED' && task.attempt >= task.maxAttempts))
|
|
65
65
|
return { status: 'FAILED', job };
|
package/dist/types.js
CHANGED
|
@@ -12,6 +12,15 @@ export function normalizeLegacyTaskLifecycle(task) {
|
|
|
12
12
|
task.maxAttempts = Math.max(3, task.maxAttempts ?? 0, task.attempt + 1);
|
|
13
13
|
task.unblock = task.unblock ? { ...task.unblock, event: 'task.unblocked' } : undefined;
|
|
14
14
|
}
|
|
15
|
+
// Migrate persisted interactive waits from their former overloaded DRAFT state.
|
|
16
|
+
// Ordinary dependency-held DRAFT Tasks remain untouched.
|
|
17
|
+
if (legacy.state === 'DRAFT' && task.attempt > 0 && task.interactiveInvocation &&
|
|
18
|
+
!task.executionId && task.interactiveInvocation.boundAt && !task.unblock &&
|
|
19
|
+
(task.interactiveInvocation.status === 'awaiting_decision' ||
|
|
20
|
+
(Boolean(task.interactiveInvocation.decidedAt) &&
|
|
21
|
+
Date.parse(task.updatedAt) <= Date.parse(task.interactiveInvocation.decidedAt)))) {
|
|
22
|
+
legacy.state = 'AWAITING_DECISION';
|
|
23
|
+
}
|
|
15
24
|
if (legacy.state === 'BLOCKED' && task.kind !== 'planner' && task.agentName !== 'troubleshooter') {
|
|
16
25
|
legacy.state = 'FAILED';
|
|
17
26
|
task.failureReason ??= task.failureReason === 'worker_outcome_unknown' ? task.failureReason : 'legacy_ordinary_blocked';
|
|
@@ -12,7 +12,7 @@ export const WORKFLOW_EVENT_NAMES = [
|
|
|
12
12
|
'hold',
|
|
13
13
|
'lease.expired',
|
|
14
14
|
'implementation.completed',
|
|
15
|
-
'
|
|
15
|
+
'task.interactive_waiting',
|
|
16
16
|
'local.completed',
|
|
17
17
|
'local.merge.requested',
|
|
18
18
|
'effect.deliverLocalMerge.failed',
|
|
@@ -26,6 +26,7 @@ export const WORKFLOW_EVENT_NAMES = [
|
|
|
26
26
|
'reconcile',
|
|
27
27
|
'recovery.reopen',
|
|
28
28
|
'release',
|
|
29
|
+
'interactive.resume',
|
|
29
30
|
'retry',
|
|
30
31
|
'review.started',
|
|
31
32
|
'review.approved',
|
|
@@ -45,7 +46,6 @@ export const WORKFLOW_EVENT_NAMES = [
|
|
|
45
46
|
'effect.launchShortcut.failed',
|
|
46
47
|
'effect.resumeShortcut.failed',
|
|
47
48
|
'task.unblocked',
|
|
48
|
-
'interactive.waiting',
|
|
49
49
|
'watchdog.failed',
|
|
50
50
|
'worker.delivery_failed',
|
|
51
51
|
'worker.start_ack_failed',
|
|
@@ -2,7 +2,7 @@ import { ConditionRegistry, booleanCondition } from './conditions.js';
|
|
|
2
2
|
import { readFileSync } from 'node:fs';
|
|
3
3
|
import { GraphRuntime } from './graph-v2.js';
|
|
4
4
|
import { WORKFLOW_EFFECT_NAMES, WORKFLOW_EVENT_NAMES, WORKFLOW_MUTATION_NAMES, } from './contracts.js';
|
|
5
|
-
const TASK_STATES = ['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'];
|
|
5
|
+
const TASK_STATES = ['DRAFT', 'QUEUED', 'RUNNING', 'AWAITING_DECISION', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'];
|
|
6
6
|
const JOB_STATES = ['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'];
|
|
7
7
|
const conditionRegistry = new ConditionRegistry([
|
|
8
8
|
...new Set(['dependenciesSatisfied', 'dependenciesUnsatisfied', 'runnable', 'dispatchable', 'recoverableExecution', 'troubleshooterRecovery', 'troubleshooterTask', 'awaitingInteractiveDecision', 'retryAvailable', 'notMerged', 'autoMerge', 'prOpen', 'reviewDisabled', 'implementationComplete', 'headAvailable', 'mergeCapable', 'localCompletionAllowed', 'localMergeReady', 'shortcutCompletionAllowed'])
|
|
@@ -62,7 +62,7 @@ export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
|
|
|
62
62
|
hasSeedWork: !((job.plans?.length ?? 0) === 0 && job.tasks.filter(task => task.kind !== 'planner').length === 0),
|
|
63
63
|
noActivePlanner: failedPlan?.manualPlanning ? false : unblockNeedsNewPlan(job) || !unconsumedUnblockTrigger(job) ? !scopedPlans.some(plan => plan.status === 'PLANNING') : false,
|
|
64
64
|
noBlockedWork: Boolean(unconsumedUnblockTrigger(job)) || !scopedTasks.some(task => task.kind !== 'planner' && isEffectivelyBlocked(task)),
|
|
65
|
-
noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && (['QUEUED', 'RUNNING'].includes(task.state) || (task.state === 'DRAFT' && !task.unblock))),
|
|
65
|
+
noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && (['QUEUED', 'RUNNING', 'AWAITING_DECISION'].includes(task.state) || (task.state === 'DRAFT' && !task.unblock))),
|
|
66
66
|
resolutionOwnedByTroubleshooter: scopedTasks.some(task => task.kind !== 'planner' && task.resolution?.owner === 'troubleshooter' && ['active', 'waiting'].includes(task.resolution.state)),
|
|
67
67
|
continuationMaterialized: Boolean(unconsumedUnblockTrigger(job)) || !(latestObjective === 'in_progress' && latestId && !job.tasks.some(task => task.kind !== 'planner' && task.planningDecisionId === latestId)),
|
|
68
68
|
objectiveUnsatisfied: latestObjective !== 'satisfied',
|
package/package.json
CHANGED
|
@@ -42,6 +42,24 @@ The automatically created `job-acceptance-reviewer` (historical `reviewer` recor
|
|
|
42
42
|
A fix child reports its **own** correlated completion after verified repair. Downstream `dependencyValidity` policy is `order-only` by default, or explicitly `revalidate`/`rerun` per declared input. All changed upstream generations must settle before a fan-in consumer can verify or rerun. Relay derives successful revision lineage from durable Task results, then creates another fresh immutable-head Job Acceptance Review. A partially submitted message, unverified terminal, historical result or stale source SHA does not count as a fix or approval.
|
|
43
43
|
|
|
44
44
|
|
|
45
|
+
## Interactive Task suspension
|
|
46
|
+
|
|
47
|
+
After binding a host invocation, a RUNNING Worker waiting for human input
|
|
48
|
+
publishes `task.interactive_waiting` with its exact Job/Task/Execution source identity.
|
|
49
|
+
Relay checks the pending invocation, persists RUNNING -> AWAITING_DECISION,
|
|
50
|
+
clears the execution lease, and releases the Worker. This is a non-failure
|
|
51
|
+
handoff and is not a Task completion or a Troubleshooter block.
|
|
52
|
+
The Job stays ACTIVE; the Task does not requeue until a matching
|
|
53
|
+
`task.interactive_decision` is durably accepted and the Task Graph selects
|
|
54
|
+
`interactive.resume` -> QUEUED. Retries and daemon restarts must not create
|
|
55
|
+
another Task. Cancellation remains legal while awaiting a decision.
|
|
56
|
+
|
|
57
|
+
The invocation record holds immutable request/revision identity and the
|
|
58
|
+
decision outcome. Its status is not the authority for the Task execution
|
|
59
|
+
lifecycle; Task.state is. The older overloaded DRAFT waiting snapshots
|
|
60
|
+
are normalized to AWAITING_DECISION when the SQLite store starts.
|
|
61
|
+
Do not use `task.blocked` to suspend an interactive Task.
|
|
62
|
+
|
|
45
63
|
## Generic interactive decision event (human review)
|
|
46
64
|
|
|
47
65
|
**Canonical type:** `task.interactive_decision`. This is a human decision for an in-progress Task (video preview, document review, image approval, etc.), **not** an Implementation terminal event or a Job Final Reviewer verdict. A UI such as Markcut is a generic publisher: it receives a caller-supplied template and fills only the declared review-result fields. It must not invent Task/Execution/source identity or a new Relay-specific event type.
|
|
@@ -7,6 +7,7 @@ flowchart LR
|
|
|
7
7
|
draft["state: DRAFT"]
|
|
8
8
|
queued["state: QUEUED"]
|
|
9
9
|
running["state: RUNNING"]
|
|
10
|
+
awaitingDecision["state: AWAITING_DECISION"]
|
|
10
11
|
blocked["state: BLOCKED"]
|
|
11
12
|
succeeded["state: SUCCEEDED"]
|
|
12
13
|
failed["state: FAILED"]
|
|
@@ -168,12 +169,14 @@ leaseFailQueuedClearLease --> leaseFailQueuedClearExecution
|
|
|
168
169
|
leaseFailQueuedClearExecution --> failed
|
|
169
170
|
queued -->|on: cancel| cancelled
|
|
170
171
|
|
|
171
|
-
running -->|on:
|
|
172
|
+
running -->|on: task.interactive_waiting| interactiveWaitAllowed
|
|
172
173
|
interactiveWaitAllowed -->|true| runningWaitClearLease
|
|
173
174
|
runningWaitClearLease["action: mutation.clearLease"]
|
|
174
175
|
runningWaitClearLease --> runningWaitClearExecution
|
|
175
176
|
runningWaitClearExecution["action: mutation.clearExecution"]
|
|
176
|
-
runningWaitClearExecution -->
|
|
177
|
+
runningWaitClearExecution --> awaitingDecision
|
|
178
|
+
awaitingDecision -->|on: interactive.resume| releaseClearError
|
|
179
|
+
awaitingDecision -->|on: cancel| cancelled
|
|
177
180
|
running -->|on: task.blocked| runningBlockAllowed
|
|
178
181
|
runningBlockAllowed -->|true| blocked
|
|
179
182
|
runningBlockAllowed -->|false| failed
|