@crewx/workflow 0.3.22-rc.21 → 0.3.22-rc.210

package/dist/src/mermaid.js

@@ -1,133 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeNodeId = safeNodeId;
-exports.escapeMermaidLabel = escapeMermaidLabel;
-exports.toMermaid = toMermaid;
-const MERMAID_RESERVED = new Set([
-    'end', 'subgraph', 'direction', 'click', 'style', 'classDef', 'class', 'linkStyle',
-]);
-function safeNodeId(nodeId) {
-    return MERMAID_RESERVED.has(nodeId) ? `node_${nodeId}` : nodeId;
-}
-function escapeMermaidLabel(s) {
-    return s
-        .replace(/"/g, '#quot;')
-        .replace(/</g, '#lt;')
-        .replace(/>/g, '#gt;')
-        .replace(/\{/g, '#123;')
-        .replace(/\}/g, '#125;')
-        .replace(/`/g, '#96;')
-        .slice(0, 50);
-}
-function buildLabel(nodeId, node) {
-    if (node.type === 'end')
-        return 'END';
-    if (node.type === 'error')
-        return 'ERROR';
-    let subtitle = '';
-    if (node.agent) {
-        subtitle = `@${escapeMermaidLabel(node.agent)}`;
-    }
-    else if (node.type === 'skill_task' && node.skill) {
-        subtitle = `skill:${escapeMermaidLabel(node.skill)}`;
-    }
-    else if (node.type === 'shell_task' && node.command && node.command[0]) {
-        subtitle = `$ ${escapeMermaidLabel(node.command[0])}`;
-    }
-    const desc = node.description ?? node.input?.split('\n')[0]?.trim() ?? '';
-    const escapedDesc = escapeMermaidLabel(desc);
-    const idPart = subtitle
-        ? `${escapeMermaidLabel(nodeId)}(${subtitle})`
-        : escapeMermaidLabel(nodeId);
-    if (!escapedDesc || escapedDesc === escapeMermaidLabel(nodeId)) {
-        return `*${idPart}*`;
-    }
-    return `*${idPart}*\n${escapedDesc}`;
-}
-function wrapShape(nodeId, label, type) {
-    const safe = safeNodeId(nodeId);
-    if (type === 'end' || type === 'error') {
-        return `${safe}(("${label}"))`;
-    }
-    const q = `"\`${label}\`"`;
-    switch (type) {
-        case 'branch':
-            return `${safe}{${q}}`;
-        case 'expression':
-            return `${safe}{{${q}}}`;
-        case 'parallel':
-            return `${safe}[/${q}/]`;
-        case 'join':
-            return `${safe}[\\${q}\\]`;
-        case 'skill_task':
-            return `${safe}[[${q}]]`;
-        case 'shell_task':
-            return `${safe}[(${q})]`;
-        default:
-            return `${safe}[${q}]`;
-    }
-}
-const NODE_STYLES = {
-    approval: 'fill:#e0f2fe,stroke:#93c5fd,color:#1e3a5f',
-    expression: 'fill:#fef3c7,stroke:#f59e0b,color:#78350f',
-    error: 'fill:#fee2e2,stroke:#f87171,color:#7f1d1d',
-};
-function toMermaid(spec) {
-    const lines = ['flowchart TD'];
-    const nodes = spec.nodes;
-    for (const [nodeId, node] of Object.entries(nodes)) {
-        const label = buildLabel(nodeId, node);
-        lines.push(`  ${wrapShape(nodeId, label, node.type)}`);
-    }
-    lines.push('');
-    for (const [nodeId, node] of Object.entries(nodes)) {
-        const src = safeNodeId(nodeId);
-        if (node.next) {
-            lines.push(`  ${src} --> ${safeNodeId(node.next)}`);
-        }
-        if (node.type === 'branch' && node.branches && !Array.isArray(node.branches)) {
-            for (const [condLabel, target] of Object.entries(node.branches)) {
-                const edgeLabel = escapeMermaidLabel(condLabel === 'true' ? '통과' : condLabel === 'false' ? '반려' : condLabel);
-                lines.push(`  ${src} -->|${edgeLabel}| ${safeNodeId(target)}`);
-            }
-        }
-        if (node.type === 'parallel' && Array.isArray(node.branches)) {
-            for (const branchId of node.branches) {
-                lines.push(`  ${src} --> ${safeNodeId(branchId)}`);
-            }
-            if (node.join) {
-                for (const branchId of node.branches) {
-                    const branchNode = nodes[branchId];
-                    if (!branchNode?.next) {
-                        lines.push(`  ${safeNodeId(branchId)} --> ${safeNodeId(node.join)}`);
-                    }
-                }
-            }
-        }
-        if (node.type === 'approval') {
-            if (node.on_approve) {
-                lines.push(`  ${src} -->|${escapeMermaidLabel('승인')}| ${safeNodeId(node.on_approve)}`);
-            }
-            if (node.on_reject) {
-                lines.push(`  ${src} -->|${escapeMermaidLabel('반려')}| ${safeNodeId(node.on_reject)}`);
-            }
-        }
-    }
-    const nodesByType = new Map();
-    for (const [nodeId, node] of Object.entries(nodes)) {
-        const list = nodesByType.get(node.type) ?? [];
-        list.push(safeNodeId(nodeId));
-        nodesByType.set(node.type, list);
-    }
-    lines.push('');
-    for (const [type, style] of Object.entries(NODE_STYLES)) {
-        lines.push(`  classDef ${type} ${style}`);
-    }
-    for (const [type, ids] of nodesByType) {
-        if (NODE_STYLES[type]) {
-            lines.push(`  class ${ids.join(',')} ${type}`);
-        }
-    }
-    return lines.join('\n');
-}
-//# sourceMappingURL=mermaid.js.map
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.safeNodeId=o;exports.escapeMermaidLabel=a;exports.toMermaid=d;const u=new Set(["end","subgraph","direction","click","style","classDef","class","linkStyle"]);function o(c){return u.has(c)?`node_${c}`:c}function a(c){return c.replace(/"/g,"#quot;").replace(/</g,"#lt;").replace(/>/g,"#gt;").replace(/\{/g,"#123;").replace(/\}/g,"#125;").replace(/`/g,"#96;").slice(0,50)}function h(c,r){if(r.type==="end")return"END";if(r.type==="error")return"ERROR";let t="";if(r.agent){t=`@${a(r.agent)}`}else if(r.type==="skill_task"&&r.skill){t=`skill:${a(r.skill)}`}else if(r.type==="shell_task"&&r.command&&r.command[0]){t=`$ ${a(r.command[0])}`}const n=r.description??r.input?.split("\n")[0]?.trim()??"";const s=a(n);const e=t?`${a(c)}(${t})`:a(c);if(!s||s===a(c)){return`*${e}*`}return`*${e}*
+${s}`}function b(c,r,t){const n=o(c);if(t==="end"||t==="error"){return`${n}(("${r}"))`}const s=`"\`${r}\`"`;switch(t){case"branch":return`${n}{${s}}`;case"expression":return`${n}{{${s}}}`;case"parallel":return`${n}[/${s}/]`;case"join":return`${n}[\\${s}\\]`;case"skill_task":return`${n}[[${s}]]`;case"shell_task":return`${n}[(${s})]`;default:return`${n}[${s}]`}}const p={approval:"fill:#e0f2fe,stroke:#93c5fd,color:#1e3a5f",expression:"fill:#fef3c7,stroke:#f59e0b,color:#78350f",error:"fill:#fee2e2,stroke:#f87171,color:#7f1d1d"};function d(c){const r=["flowchart TD"];const t=c.nodes;for(const[s,e]of Object.entries(t)){const i=h(s,e);r.push(`  ${b(s,i,e.type)}`)}r.push("");for(const[s,e]of Object.entries(t)){const i=o(s);if(e.next){r.push(`  ${i} --> ${o(e.next)}`)}if(e.type==="branch"&&e.branches&&!Array.isArray(e.branches)){for(const[l,f]of Object.entries(e.branches)){const $=a(l==="true"?"Approve":l==="false"?"Reject":l);r.push(`  ${i} -->|${$}| ${o(f)}`)}}if(e.type==="parallel"&&Array.isArray(e.branches)){for(const l of e.branches){r.push(`  ${i} --> ${o(l)}`)}if(e.join){for(const l of e.branches){const f=t[l];if(!f?.next){r.push(`  ${o(l)} --> ${o(e.join)}`)}}}}if(e.type==="approval"){if(e.on_approve){r.push(`  ${i} -->|${a("Approve")}| ${o(e.on_approve)}`)}if(e.on_reject){r.push(`  ${i} -->|${a("Reject")}| ${o(e.on_reject)}`)}}}const n=new Map;for(const[s,e]of Object.entries(t)){const i=n.get(e.type)??[];i.push(o(s));n.set(e.type,i)}r.push("");for(const[s,e]of Object.entries(p)){r.push(`  classDef ${s} ${e}`)}for(const[s,e]of n){if(p[s]){r.push(`  class ${e.join(",")} ${s}`)}}return r.join("\n")}

package/dist/src/parent-task-sync.d.ts

@@ -0,0 +1,139 @@
+import type { RunExecution } from './types.js';
+export type WorkflowParentTaskStatus = 'pending' | 'running' | 'success' | 'failed';
+export type WorkflowParentTaskKind = 'workflow_card' | 'workflow_ui_instance';
+export interface WorkflowParentTaskLookup {
+    workspaceId: string;
+    workflowRunId: string;
+    kind: WorkflowParentTaskKind;
+}
+export interface WorkflowParentLifecycle {
+    status: WorkflowParentTaskStatus;
+    error: string | null;
+    completedAt: string | null;
+    durationMs: number | null;
+}
+export interface WorkflowParentLifecycleSnapshot {
+    status: string;
+    error: string | null;
+    completedAt: string | null;
+    durationMs: number | null;
+}
+export interface WorkflowParentLifecycleChange {
+    id: string;
+    kind: WorkflowParentTaskKind;
+    before: WorkflowParentLifecycleSnapshot;
+    after: WorkflowParentLifecycle;
+    reason: string;
+}
+export interface WorkflowParentTaskRow {
+    id: string;
+    agent_id: string;
+    thread_id: string | null;
+    workspace_id: string | null;
+    platform: string | null;
+    status: string;
+    error: string | null;
+    completed_at: string | null;
+    duration_ms: number | null;
+    started_at: string;
+    metadata: string | null;
+}
+export interface WorkflowParentTaskRepository {
+    findRunningWorkflowParentTasks(): WorkflowParentTaskRow[];
+    findWorkflowParentTask(opts: WorkflowParentTaskLookup): WorkflowParentTaskRow | undefined;
+    updateTaskLifecycle(opts: {
+        id: string;
+        status: WorkflowParentTaskStatus;
+        error: string | null;
+        completedAt: string | null;
+        durationMs: number | null;
+        workspaceId: string;
+    }): void;
+}
+export interface WorkflowParentPersistTaskRepository {
+    findWorkflowParentTask(opts: WorkflowParentTaskLookup): WorkflowParentTaskRow | undefined;
+    updateTaskLifecycle: WorkflowParentTaskRepository['updateTaskLifecycle'];
+}
+export interface SyncWorkflowParentTaskLifecycleOptions {
+    taskRepo: Pick<WorkflowParentPersistTaskRepository, 'updateTaskLifecycle'>;
+    row: WorkflowParentTaskRow;
+    run: RunExecution;
+    workspaceId: string;
+    kind: WorkflowParentTaskKind;
+    snapshotUpdatedAt?: string | null;
+}
+export interface WorkflowParentPersistSinkOptions {
+    taskRepo: WorkflowParentPersistTaskRepository;
+    workspaceId: string;
+    parentKinds?: readonly WorkflowParentTaskKind[];
+}
+export interface WorkflowParentPersistResult {
+    changedParentTaskIds: string[];
+    linkedAuditInstanceIds: string[];
+}
+export interface DeriveWorkflowParentLifecycleChangeOptions {
+    row: WorkflowParentTaskRow;
+    run: RunExecution;
+    workspaceId: string;
+    kind: WorkflowParentTaskKind;
+    snapshotUpdatedAt?: string | null;
+}
+export type WorkflowParentLifecycleDecisionStatus = 'ineligible' | 'unchanged' | 'stale-suppressed' | 'changed';
+export interface WorkflowParentLifecycleDecision {
+    status: WorkflowParentLifecycleDecisionStatus;
+    change: WorkflowParentLifecycleChange | null;
+    linkedAuditInstanceId: string | null;
+}
+export interface PreviewWorkflowParentRepairOptions {
+    taskRepo: Pick<WorkflowParentPersistTaskRepository, 'findWorkflowParentTask'>;
+    run: RunExecution;
+    workspaceId: string;
+    parentKinds?: readonly WorkflowParentTaskKind[];
+}
+export interface WorkflowParentRepairPreview {
+    runId: string;
+    runStatus: NonNullable<RunExecution['status']>;
+    changes: WorkflowParentLifecycleChange[];
+    linkedAuditInstanceIds: string[];
+}
+export interface ReconcileWorkflowParentTasksOptions {
+    taskRepo: WorkflowParentTaskRepository;
+    resolveWorkspacePath: (workspaceId: string) => string | undefined;
+    loadRun: (workspacePath: string, workflowRunId: string) => RunExecution | null;
+    orphanGraceMs?: number;
+    nowMs?: number;
+}
+export interface WorkflowParentWorkspace {
+    workspaceId: string;
+    workspacePath: string;
+}
+export type WorkflowParentReconciliationSkipReason = 'no-marker' | 'no-workspace-id' | 'no-workspace-path' | 'run-missing' | 'not-stale' | 'ineligible' | 'suppressed';
+export type WorkflowParentReconciliationSkipCounts = Partial<Record<WorkflowParentReconciliationSkipReason, number>>;
+export interface ReconcileWorkflowParentRunFilesOptions {
+    taskRepo: WorkflowParentPersistTaskRepository;
+    workspaces: readonly WorkflowParentWorkspace[];
+    listRunIds: (workspacePath: string) => readonly string[];
+    readRun: (workspacePath: string, workflowRunId: string) => RunExecution | null;
+    listWorkflowParentTasks?: (workspaceId: string) => readonly WorkflowParentTaskRow[];
+    parentKinds?: readonly WorkflowParentTaskKind[];
+}
+export interface WorkflowParentReconciliationResult {
+    aligned: number;
+    orphaned: number;
+    skipped: number;
+    scanned?: number;
+    skippedBy?: WorkflowParentReconciliationSkipCounts;
+    runFilesScanned?: number;
+}
+export declare const WORKFLOW_PARENT_ORPHAN_GRACE_MS: number;
+export declare const WORKFLOW_PARENT_ORPHAN_ERROR = "Workflow run file missing after grace period (orphaned workflow task)";
+export declare const WORKFLOW_PARENT_TASK_KINDS: readonly WorkflowParentTaskKind[];
+export declare function deriveWorkflowParentLifecycle(run: RunExecution): WorkflowParentLifecycle | null;
+export declare function deriveWorkflowParentLifecycleDecision(options: DeriveWorkflowParentLifecycleChangeOptions): WorkflowParentLifecycleDecision;
+export declare function deriveWorkflowParentLifecycleChange(options: DeriveWorkflowParentLifecycleChangeOptions): WorkflowParentLifecycleChange | null;
+export declare function syncWorkflowParentTaskLifecycle(options: SyncWorkflowParentTaskLifecycleOptions): boolean;
+export declare function previewWorkflowParentRepair(options: PreviewWorkflowParentRepairOptions): WorkflowParentRepairPreview;
+export declare function createWorkflowParentPersistSink(options: WorkflowParentPersistSinkOptions): (run: RunExecution) => WorkflowParentPersistResult;
+export declare function reconcileWorkflowParentTasks(options: ReconcileWorkflowParentTasksOptions): WorkflowParentReconciliationResult;
+export declare function reconcileWorkflowParentRunFiles(options: ReconcileWorkflowParentRunFilesOptions): WorkflowParentReconciliationResult;
+                                              

package/dist/src/parent-task-sync.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.WORKFLOW_PARENT_TASK_KINDS=exports.WORKFLOW_PARENT_ORPHAN_ERROR=exports.WORKFLOW_PARENT_ORPHAN_GRACE_MS=void 0;exports.deriveWorkflowParentLifecycle=p;exports.deriveWorkflowParentLifecycleDecision=k;exports.deriveWorkflowParentLifecycleChange=T;exports.syncWorkflowParentTaskLifecycle=K;exports.previewWorkflowParentRepair=M;exports.createWorkflowParentPersistSink=L;exports.reconcileWorkflowParentTasks=E;exports.reconcileWorkflowParentRunFiles=v;exports.WORKFLOW_PARENT_ORPHAN_GRACE_MS=10*60*1e3;exports.WORKFLOW_PARENT_ORPHAN_ERROR="Workflow run file missing after grace period (orphaned workflow task)";exports.WORKFLOW_PARENT_TASK_KINDS=["workflow_card","workflow_ui_instance"];function w(e){let n;for(const t of e.audit??[]){const r=Date.parse(t.ended_at);if(!Number.isFinite(r))continue;if(!n||r>=n.timestamp){n={value:t.ended_at,timestamp:r}}}return n?.value??null}function p(e){if(e.status==="completed"||e.status==="failed"||e.status==="cancelled"){const n=w(e)??e.updated_at;const t=Date.parse(e.created_at);const r=Date.parse(n);const a=Number.isFinite(t)&&Number.isFinite(r)?Math.max(0,r-t):null;if(e.status==="completed"){return{status:"success",error:null,completedAt:n,durationMs:a}}return{status:"failed",error:e.error??(e.status==="cancelled"?"Workflow run cancelled":"Workflow run failed"),completedAt:n,durationMs:a}}if(e.status==="running"||e.status==="retrying"){return{status:"running",error:null,completedAt:null,durationMs:null}}if(e.status==="pending"||e.status===void 0){return{status:"pending",error:null,completedAt:null,durationMs:null}}return null}function _(e){if(!e)return null;try{const n=JSON.parse(e);if(!n||typeof n!=="object"||Array.isArray(n))return null;const t=n;return(t.kind==="workflow_card"||t.kind==="workflow_ui_instance")&&typeof t.workflowRunId==="string"?{kind:t.kind,workflowRunId:t.workflowRunId,...typeof t.uiInstanceId==="string"&&t.uiInstanceId.trim()?{uiInstanceId:t.uiInstanceId.trim()}:{}}:null}catch{return null}}function h(e,n){return e.status===n.status&&e.error===n.error&&e.completed_at===n.completedAt&&e.duration_ms===n.durationMs}function O(e){return e==="success"||e==="completed"||e==="failed"||e==="cancelled"||e==="error"}function N(e,n,t){if(!O(e.status))return false;if(!e.completed_at)return false;const r=Date.parse(e.completed_at);const a=Date.parse(t??n.updated_at);if(!Number.isFinite(r)||!Number.isFinite(a))return true;return r>=a}function k(e){const n=()=>({status:"ineligible",change:null,linkedAuditInstanceId:null});if(e.row.platform!=="workflow"||e.row.workspace_id!==e.workspaceId){return n()}const t=_(e.row.metadata);if(!t||t.kind!==e.kind||t.workflowRunId!==e.run.id){return n()}const r=p(e.run);if(!r)return n();const a=t.kind==="workflow_ui_instance"?t.uiInstanceId??null:null;if(h(e.row,r)){return{status:"unchanged",change:null,linkedAuditInstanceId:a}}if((r.status==="running"||r.status==="pending")&&N(e.row,e.run,e.snapshotUpdatedAt)){return{status:"stale-suppressed",change:null,linkedAuditInstanceId:null}}const i=e.run.status??"pending";const o=i==="pending"?"Persisted run is pending (or legacy statusless); no execution outcome is inferred.":`Persisted run status "${i}" is projected to the parent lifecycle.`;return{status:"changed",linkedAuditInstanceId:a,change:{id:e.row.id,kind:e.kind,before:{status:e.row.status,error:e.row.error,completedAt:e.row.completed_at,durationMs:e.row.duration_ms},after:r,reason:o}}}function T(e){return k(e).change}function R(e,n){e.taskRepo.updateTaskLifecycle({id:e.row.id,status:n.after.status,error:n.after.error,completedAt:n.after.completedAt,durationMs:n.after.durationMs,workspaceId:e.workspaceId})}function K(e){const n=k(e).change;if(!n)return false;R(e,n);return true}function A(e){const n=[];for(const t of e.parentKinds){const r=e.taskRepo.findWorkflowParentTask({workspaceId:e.workspaceId,workflowRunId:e.run.id,kind:t});if(!r)continue;n.push({kind:t,row:r,decision:k({row:r,run:e.run,workspaceId:e.workspaceId,kind:t,snapshotUpdatedAt:w(e.run)})})}return n}function S(e,n){const t=new Map;for(const r of n){if(r.platform!=="workflow"||r.workspace_id!==e)continue;const a=_(r.metadata);if(!a)continue;const i=t.get(a.kind)??new Map;if(!i.has(a.workflowRunId)){i.set(a.workflowRunId,r)}t.set(a.kind,i)}return{findWorkflowParentTask:r=>{if(r.workspaceId!==e)return void 0;return t.get(r.kind)?.get(r.workflowRunId)}}}function M(e){const n=e.parentKinds??exports.WORKFLOW_PARENT_TASK_KINDS;const t=[];const r=new Set;for(const{decision:a}of A({taskRepo:e.taskRepo,run:e.run,workspaceId:e.workspaceId,parentKinds:n})){if(a.linkedAuditInstanceId){r.add(a.linkedAuditInstanceId)}if(a.change)t.push(a.change)}return{runId:e.run.id,runStatus:e.run.status??"pending",changes:t,linkedAuditInstanceIds:[...r]}}function L(e){const n=e.parentKinds??exports.WORKFLOW_PARENT_TASK_KINDS;return t=>{const r=[];const a=new Set;if(!p(t)){return{changedParentTaskIds:r,linkedAuditInstanceIds:[]}}for(const{kind:i,row:o,decision:s}of A({taskRepo:e.taskRepo,run:t,workspaceId:e.workspaceId,parentKinds:n})){if(s.linkedAuditInstanceId){a.add(s.linkedAuditInstanceId)}if(s.change){R({taskRepo:e.taskRepo,row:o,run:t,workspaceId:e.workspaceId,kind:i,snapshotUpdatedAt:w(t)},s.change);r.push(o.id)}}return{changedParentTaskIds:r,linkedAuditInstanceIds:[...a]}}}function F(e,n,t){const r=Date.parse(e);return Number.isFinite(r)&&n-r>=t}function m(){return{}}function u(e,n){e.skipped+=1;const t=e.skippedBy??(e.skippedBy={});t[n]=(t[n]??0)+1}function E(e){const n=e.orphanGraceMs??exports.WORKFLOW_PARENT_ORPHAN_GRACE_MS;const t=e.nowMs??Date.now();const r={aligned:0,orphaned:0,scanned:0,skipped:0,skippedBy:m()};const a=s=>{u(r,s)};const i=new Map;const o=s=>{if(!i.has(s)){i.set(s,e.resolveWorkspacePath(s))}return i.get(s)};for(const s of e.taskRepo.findRunningWorkflowParentTasks()){r.scanned=(r.scanned??0)+1;const l=_(s.metadata);if(s.platform!=="workflow"||!l){a("no-marker");continue}const c=s.workspace_id;if(!c){a("no-workspace-id");continue}const d=o(c);if(!d){a("no-workspace-path");continue}const W=l.workflowRunId;let f=null;try{f=e.loadRun(d,W)}catch{}if(!f){if(s.status!=="running"||!F(s.started_at,t,n)){a(s.status==="running"?"not-stale":"run-missing");continue}const y=s.completed_at??new Date(t).toISOString();const g=s.duration_ms??Math.max(0,t-Date.parse(s.started_at));e.taskRepo.updateTaskLifecycle({id:s.id,status:"failed",error:exports.WORKFLOW_PARENT_ORPHAN_ERROR,completedAt:y,durationMs:Number.isFinite(g)?g:null,workspaceId:c});r.orphaned+=1;continue}const P=p(f);if(!P){a("not-stale");continue}if(h(s,P))continue;const I=k({row:s,run:f,workspaceId:c,kind:l.kind});if(I.status==="stale-suppressed"){a("not-stale");continue}if(I.change){R({taskRepo:e.taskRepo,row:s,run:f,workspaceId:c,kind:l.kind},I.change);r.aligned+=1}}return r}function v(e){const n={aligned:0,orphaned:0,skipped:0,skippedBy:m(),runFilesScanned:0};for(const t of e.workspaces){if(!t.workspaceId){u(n,"no-workspace-id");continue}if(!t.workspacePath){u(n,"no-workspace-path");continue}const r=e.listWorkflowParentTasks?S(t.workspaceId,e.listWorkflowParentTasks(t.workspaceId)):e.taskRepo;let a=[];try{a=e.listRunIds(t.workspacePath)}catch{u(n,"no-workspace-path");continue}for(const i of a){n.runFilesScanned=(n.runFilesScanned??0)+1;let o=null;try{o=e.readRun(t.workspacePath,i)}catch{}if(!o||typeof o.id!=="string"){u(n,"run-missing");continue}const s=e.parentKinds??exports.WORKFLOW_PARENT_TASK_KINDS;for(const{kind:l,row:c,decision:d}of A({taskRepo:r,run:o,workspaceId:t.workspaceId,parentKinds:s})){if(d.status==="stale-suppressed"){u(n,"suppressed");continue}if(d.status==="ineligible"){u(n,"ineligible");continue}if(!d.change)continue;R({taskRepo:e.taskRepo,row:c,run:o,workspaceId:t.workspaceId,kind:l,snapshotUpdatedAt:w(o)},d.change);n.aligned+=1}}}return n}

package/dist/src/retry-policy.d.ts

@@ -0,0 +1,38 @@
+import type { RetryPolicy } from './types';
+export declare const RETRY_BASE_DELAY_MS = 1000;
+export declare const RETRY_DEFAULT_MAX_DELAY_MS = 30000;
+export declare const RETRY_HARD_MAX_DELAY_MS = 60000;
+export declare const RETRY_MAX_ATTEMPTS_CEILING = 10;
+export declare const DEFAULT_RETRYABLE_CODES: readonly ["NODE_EXIT_NONZERO", "NODE_TIMEOUT", "SPAWN_FAILED"];
+export declare const RETRYABLE_NODE_TYPES: readonly ["agent_task", "skill_task", "shell_task"];
+export type RetryPolicyParseResult = {
+    ok: true;
+    policy: RetryPolicy | undefined;
+} | {
+    ok: false;
+    path: string;
+    reason: string;
+};
+export declare function parseRetryPolicy(node: unknown): RetryPolicyParseResult;
+export interface RetryDecisionRun {
+    status?: 'pending' | 'running' | 'retrying' | 'completed' | 'failed' | 'cancelled';
+    last_failure?: {
+        failedNode?: unknown;
+        attempt?: unknown;
+        causeCode?: unknown;
+    };
+    node_attempts?: Record<string, unknown>;
+}
+export interface RetryDecisionInput {
+    policy?: RetryPolicy;
+    run: RetryDecisionRun;
+    nodeId: string;
+}
+export interface RetryDecision {
+    retry: boolean;
+    reason: string;
+    attempt?: number;
+}
+export declare function decideRetry(input: RetryDecisionInput): RetryDecision;
+export declare function computeRetryDelayMs(policy: RetryPolicy, attempt: number): number;
+                                          

package/dist/src/retry-policy.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.RETRYABLE_NODE_TYPES=exports.DEFAULT_RETRYABLE_CODES=exports.RETRY_MAX_ATTEMPTS_CEILING=exports.RETRY_HARD_MAX_DELAY_MS=exports.RETRY_DEFAULT_MAX_DELAY_MS=exports.RETRY_BASE_DELAY_MS=void 0;exports.parseRetryPolicy=f;exports.decideRetry=A;exports.computeRetryDelayMs=T;const d=require("./types");exports.RETRY_BASE_DELAY_MS=1e3;exports.RETRY_DEFAULT_MAX_DELAY_MS=3e4;exports.RETRY_HARD_MAX_DELAY_MS=6e4;exports.RETRY_MAX_ATTEMPTS_CEILING=10;exports.DEFAULT_RETRYABLE_CODES=["NODE_EXIT_NONZERO","NODE_TIMEOUT","SPAWN_FAILED"];exports.RETRYABLE_NODE_TYPES=["agent_task","skill_task","shell_task"];const R=new Set(["CLI_UNRESOLVABLE","SPAWN_FAILED","NODE_TIMEOUT","NODE_EXIT_NONZERO","OUTPUT_INVALID","RATE_LIMITED","CONFIG_INVALID","INTERRUPTED","CANCELLED","UNKNOWN"]);function l(t){return typeof t==="object"&&t!==null&&!Array.isArray(t)}function r(t,e){return{ok:false,path:t,reason:e}}function f(t){if(!l(t))return r("retry","node must be an object");const e=t.retry;if(e===void 0)return{ok:true,policy:void 0};if(!l(e))return r("retry","retry must be an object");const _=t.type;if(typeof _!=="string"||!exports.RETRYABLE_NODE_TYPES.includes(_)){return r("retry","retry is only supported on agent_task, skill_task, and shell_task nodes")}const n=e.max;if(typeof n!=="number"||!Number.isFinite(n)){return r("retry.max","retry.max must be a finite number")}if(!Number.isInteger(n))return r("retry.max","retry.max must be an integer");if(n<0||n>exports.RETRY_MAX_ATTEMPTS_CEILING){return r("retry.max",`retry.max must be between 0 and ${exports.RETRY_MAX_ATTEMPTS_CEILING}`)}const a=e.delay;if(a!=="fixed"&&a!=="exponential"){return r("retry.delay",'retry.delay must be "fixed" or "exponential"')}let i=exports.RETRY_DEFAULT_MAX_DELAY_MS;if(e.max_delay!==void 0){if(typeof e.max_delay!=="number"||!Number.isFinite(e.max_delay)){return r("retry.max_delay","retry.max_delay must be a finite number")}if(!Number.isInteger(e.max_delay)||e.max_delay<0){return r("retry.max_delay","retry.max_delay must be a non-negative integer")}i=e.max_delay}let u=[...exports.DEFAULT_RETRYABLE_CODES];if(e.on!==void 0){if(!Array.isArray(e.on))return r("retry.on","retry.on must be an array");u=[];for(const[E,o]of e.on.entries()){if(typeof o!=="string"||!R.has(o)){return r(`retry.on[${E}]`,`retry.on[${E}] is not a supported workflow failure code`)}const y=o;if(d.NEVER_RETRYABLE.includes(y)){return r(`retry.on[${E}]`,`${y} cannot be retried`)}u.push(y)}}return{ok:true,policy:{max:n,delay:a,max_delay:i,on:u}}}function s(t){return{retry:false,reason:t}}function A(t){const{policy:e,run:_,nodeId:n}=t;if(!e)return s("retry policy is not configured");if(_.status!=="failed")return s("run is not failed");const a=_.last_failure;if(!a||a.failedNode!==n)return s("latest failure is not for this node");const i=a.attempt;const u=_.node_attempts?.[n];if(typeof i!=="number"||!Number.isInteger(i)||i<=0||u!==i){return s("latest attempt is stale")}const E=a.causeCode;if(typeof E!=="string")return s("latest failure has no supported cause");if(d.NEVER_RETRYABLE.includes(E)){return s("latest failure is never retryable")}if(!e.on.includes(E)){return s("latest failure is outside the retry policy")}if(i>=e.max+1)return s("retry budget is exhausted");return{retry:true,reason:"retry policy matched",attempt:i}}function T(t,e){const _=Number.isInteger(e)&&e>0?e:1;const n=t.delay==="exponential"?exports.RETRY_BASE_DELAY_MS*2**(_-1):exports.RETRY_BASE_DELAY_MS;const a=typeof t.max_delay==="number"&&Number.isFinite(t.max_delay)?Math.max(0,t.max_delay):exports.RETRY_DEFAULT_MAX_DELAY_MS;return Math.min(n,a,exports.RETRY_HARD_MAX_DELAY_MS)}

package/dist/src/run-manager.d.ts

@@ -1,23 +1,47 @@
-import type { RunExecution, AutoRunResult } from './types';
+import type { RunExecution, WorkflowSpec, AutoRunResult } from './types';
+export { FileLock } from './file-lock';
 export declare const SKILL_TASK_DEFAULT_TIMEOUT = 600000;
+export declare const WORKFLOW_CANCEL_GRACE_MS = 2000;
+export declare const WORKFLOW_RUN_INTERRUPTED_ERROR = "Workflow run interrupted: runner process exited before completion";
+export declare const WORKFLOW_RUN_LEGACY_RECOVERY_GRACE_MS: number;
+export type RunPersistedSink = (run: RunExecution) => void;
+export interface RunManagerDependencies {
+    sleep?: (ms: number) => Promise<void>;
+    onRunPersisted?: RunPersistedSink;
+}
 export declare function parseSetArgs(args: string[]): Record<string, unknown>;
 export declare function readStdin(): Promise<string>;
 export declare function interpolateTemplate(template: string, state: Record<string, unknown>): string;
 export declare function safeEvaluate(expr: string, state: Record<string, unknown>): unknown;
 export declare function safeEvaluateBranchCondition(expr: string, state: Record<string, unknown>): unknown;
 export declare function validateSafeBranchCondition(expr: string): void;
+export declare function normalizeRunStatus(run: RunExecution, nowMs?: number): RunExecution;
+export declare function isRetryableFailure(run: RunExecution, spec: WorkflowSpec): boolean;
 export declare class RunManager {
     private runsDir;
     private readonly resolvedDir;
     private readonly projectRoot;
-    constructor(runsDir?: string, projectRoot?: string);
+    private readonly sleep;
+    private readonly onRunPersisted?;
+    constructor(runsDir?: string, projectRoot?: string, deps?: RunManagerDependencies);
     ensureRunsDir(): void;
     private validateExecId;
+    private isRunCancelled;
+    private processCancellation;
+    private readRunRaw;
+    readRun(execId: string): RunExecution | null;
+    private isLegacyStatuslessStale;
+    withRunLock<T>(execId: string, callback: (run: RunExecution) => T): T;
+    private hasStaleRunner;
+    private recoverStaleRunner;
     loadRun(execId: string): RunExecution | null;
     saveRun(run: RunExecution): void;
     atomicUpdate(execId: string, updater: (run: RunExecution) => void): RunExecution;
     atomicUpdateAsync(execId: string, updater: (run: RunExecution) => void): Promise<RunExecution>;
+    private reserveNodeAttempt;
+    private clearNodeAttempt;
     private loadWorkflowYaml;
+    getNodeType(workflowFile: string, workflowId: string, nodeId: string): string | null;
     start(yamlPath: string, workflowId?: string, overrides?: Record<string, unknown>): RunExecution;
     getState(execId: string): Record<string, unknown>;
     setState(execId: string, updates: Record<string, unknown>): void;
@@ -26,11 +50,21 @@ export declare class RunManager {
         dryRun?: boolean;
         trigger?: 'manual' | 'auto';
     }): Promise<RunExecution>;
+    private claimAutoRunLease;
+    private releaseAutoRunLease;
+    private failAutoConfiguration;
+    private reserveAutoRetry;
+    private waitForRetry;
+    private runNodeWithRetry;
     runAuto(execId: string): Promise<AutoRunResult>;
     cancelRun(execId: string, reason?: string): RunExecution;
     reset(execId: string): RunExecution;
+    retry(execId: string, options?: {
+        autoRun?: boolean;
+    }): RunExecution;
+    listRunIds(): string[];
     listRuns(opts?: {
         workflowId?: string;
     }): RunExecution[];
 }
-//# sourceMappingURL=run-manager.d.ts.map
+