@crewx/workflow 0.3.22-rc.14 → 0.3.22-rc.140

package/SKILL.md

@@ -221,6 +221,42 @@ analyze:
   next: calculate
 ```
 
+#### agent_task — execution context & failure signaling
+
+Every `agent_task` prompt is automatically prefixed with a `<crewx.workflow>` preamble
+telling the agent it runs headless inside a workflow node (workflow ID, node ID, run ID),
+that clarifying questions are impossible, and how to signal failure. Disable with
+`CREWX_WORKFLOW_PREAMBLE=off`.
+
+Two semantic-failure channels stop the run at the node (in addition to non-zero exit codes):
+
+1. **`workflow_signal` (agent-initiated)** — the agent outputs exactly one JSON object:
+
+   ```json
+   {"workflow_signal": "fail", "reason": "build is red — tsc reports 14 errors"}
+   ```
+
+   The engine detects it (pure JSON or embedded in prose), marks the node failed, and
+   records the reason in `run.error`. This is the agent's `exit 1`.
+
+2. **`fail_when` (node-declared)** — a safe expression evaluated against state *after*
+   the node's output is stored. Truthy → node fails, run halts. The judged output is
+   still preserved in state for inspection. No separate `check_*` branch node needed.
+
+   ```yaml
+   verify:
+     type: agent_task
+     agent: core_dev
+     output: verify_result
+     output_format: json
+     fail_when: 'state.verify_result.status !== "pass"'
+     next: smoke_test
+   ```
+
+   `fail_when` works on `agent_task`, `skill_task`, and `shell_task`. It uses the same
+   safe expression subset as `branch` conditions (`includes()`, `===`, `&&`, `Number()`...).
+   Use `branch` when failure should route somewhere; use `fail_when` when failure should stop the run.
+
 #### agent_task — JSON output mode
 
 When `output_format: json`, the engine requires the agent to return a single JSON object.
@@ -298,7 +334,7 @@ extract_attachments:
 | `output_schema` | object | No | Standard JSON Schema 2020-12 for parsed output. |
 | `output_retry` | integer | No | Retry attempts if JSON parse or schema validation fails. |
 
-`skill_task` uses `CREWX_CLI` (default: `npx crewx`) and executes the equivalent of:
+`skill_task` uses `CREWX_CLI` (default: `crewx`) and executes the equivalent of:
 
 ```bash
 crewx skill <skill> ...args
@@ -561,7 +597,7 @@ Examples:
 | Input | Run behavior |
 |-------|--------------|
 | `/wf rc-publish` | Starts `rc-publish` in auto mode |
-| `/wf rc-publish 미리승인한다` | Starts `rc-publish` with `state.input = "미리승인한다"` |
+| `/wf rc-publish pre-approved` | Starts `rc-publish` with `state.input = "pre-approved"` |
 | `/wf rc-publish --manual dry run` | Creates the run in manual mode with `state.input = "dry run"` |
 | `/wf rc-publish --auto prepare RC notes` | Explicit auto mode; same as default |
 
@@ -589,7 +625,7 @@ Branches and templates may also read `state.input`:
 condition: state.input.includes("dry run")
 ```
 
-Important security rule: `state.input` is **not authority**. It may influence prompts, branches, and templates, but it must never bypass an `approval` node. For example, `/wf rc-publish 미리승인한다` stores the text in `state.input`; it does not approve publishing. Approval still requires the signed ChatCard action button.
+Important security rule: `state.input` is **not authority**. It may influence prompts, branches, and templates, but it must never bypass an `approval` node. For example, `/wf rc-publish pre-approved` stores the text in `state.input`; it does not approve publishing. Approval still requires the signed ChatCard action button.
 
 ### Stored ChatCard
 
@@ -645,7 +681,7 @@ Rules:
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `CREWX_WORKSPACE` | Workspace directory (where `workflows/` lives) | `.` |
-| `CREWX_CLI` | CrewX CLI path (for `agent_task` and `skill_task`) | `npx crewx` |
+| `CREWX_CLI` | CrewX CLI path (for `agent_task` and `skill_task`) | `crewx` |
 | `CREWX_WORKFLOW_TIMEOUT` | `agent_task` execution timeout (ms) | `1800000` (30 min) |
 | `CREWX_WORKFLOW_SHELL` | First safety gate for `shell_task`; must be `1` | unset |
 | `CREWX_CONFIG` | Custom config file path | `crewx.yaml` |

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":";AAgBA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,cAAc,EAAgB,YAAY,EAA+B,MAAM,aAAa,CAAC;AA6F3G,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;CACrC;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,cAAc,EACtB,SAAS,CAAC,EAAE,cAAc,EAAE,GAC3B,gBAAgB,CAkDlB;AAmxBD,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAClC,MAAM,GAAG,IAAI,CAoBf;AAMD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,EAAE,CAsB1E;AA4CD,wBAAsB,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsD9D"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":";AAkBA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAS9C,OAAO,KAAK,EAAE,cAAc,EAAgB,YAAY,EAA6C,MAAM,aAAa,CAAC;AAqHzH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;CACrC;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,cAAc,EACtB,SAAS,CAAC,EAAE,cAAc,EAAE,GAC3B,gBAAgB,CAkDlB;AAmhCD,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAClC,MAAM,GAAG,IAAI,CAoBf;AAMD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,EAAE,CAsB1E;AA4CD,wBAAsB,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA2D9D"}

package/dist/cli.js

@@ -42,8 +42,12 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const yaml = __importStar(require("js-yaml"));
+const sdk_1 = require("@crewx/sdk");
+const repository_1 = require("@crewx/sdk/repository");
 const engine_1 = require("./src/engine");
 const run_manager_1 = require("./src/run-manager");
+const workflow_persistence_1 = require("./src/workflow-persistence");
+const parent_task_sync_1 = require("./src/parent-task-sync");
 const knowledge_core_1 = require("@crewx/knowledge-core");
 let PKG_VERSION = 'unknown';
 try {
@@ -63,7 +67,9 @@ async function loadTracer() {
         return null;
     }
 }
-const BOOLEAN_FLAGS = new Set(['help', 'json', 'mermaid', 'version', 'no-exec', 'auto']);
+const BOOLEAN_FLAGS = new Set([
+    'help', 'json', 'mermaid', 'version', 'no-exec', 'auto', 'no-run', 'apply', 'dry-run',
+]);
 function parseArgs(args) {
     const result = { positional: [], options: {} };
     for (let i = 0; i < args.length; i++) {
@@ -120,6 +126,20 @@ function getWorkflowConfig() {
         return { paths: ['workflows'] };
     }
 }
+function getNodeResultStatus(run, nodeId, nodeType, noExec) {
+    if (noExec)
+        return null;
+    const audit = [...(run.audit ?? [])]
+        .reverse()
+        .find((entry) => entry.node_id === nodeId && entry.type !== 'retry');
+    if (!audit)
+        return null;
+    if (audit.error || nodeType === 'error')
+        return 'failed';
+    if (nodeType === 'approval' || nodeType === 'parallel')
+        return 'paused';
+    return 'completed';
+}
 function validateSlugInput(nameOrPath) {
     if (!nameOrPath.endsWith('.yaml') && !nameOrPath.endsWith('.yml')) {
         if (/[/\\]|\.\./.test(nameOrPath)) {
@@ -182,6 +202,11 @@ function loadAllWorkflows(engine, paths) {
     }
     return all;
 }
+function resolveWorkflowSpecForRun(run, engine) {
+    const runFile = path.resolve(run.workflow_file);
+    const workflows = engine.loadWorkflows(path.dirname(runFile));
+    return workflows?.find((workflow) => path.resolve(workflow.filePath) === runFile && workflow.id === run.workflow_id)?.spec;
+}
 function printUsage() {
     console.log(`
 @crewx/workflow@${PKG_VERSION} - Workflow management for CrewX
@@ -199,13 +224,18 @@ Commands:
   workflow run node <id> <node>    Execute node (auto-invoke agent)
   workflow run auto <id>           Auto-run from current node until end/pause
   workflow run reset <id>          Reset execution
+  workflow run retry <id>          Retry a failed run from the failed node (--no-run: transition only)
+                                    ⚠️  re-executes the failed node; safe only if it is idempotent
   workflow run list                List all executions
+  workflow repair <run-id>         Preview parent-task repair (use --apply to write)
   workflow usage                   Show detailed guide
 
 Options:
   --json                           JSON output
   --mermaid                        Output Mermaid diagram (show only)
   --no-exec                        Move cursor only, skip agent execution (run node)
+  --dry-run                        Preview workflow parent repair without writes (default)
+  --apply                          Apply workflow parent repair under the run lock
   --version                        Show version
   --help, -h                       Show this help
 
@@ -289,7 +319,7 @@ function cmdList(engine, jsonMode) {
         }, null, 2));
     }
     else {
-        console.log(`\uD83D\uDCCB \uC6CC\uD06C\uD50C\uB85C \uBAA9\uB85D`);
+        console.log('📋 Workflows');
         workflows.forEach((wf, i) => {
             const meta = wf.spec.metadata ?? {};
             const nodeCount = wf.spec.nodes ? Object.keys(wf.spec.nodes).length : 0;
@@ -299,8 +329,8 @@ function cmdList(engine, jsonMode) {
         const firstId = workflows[0]?.id;
         if (firstId) {
             console.log(`\n${'━'.repeat(43)}`);
-            console.log(`🔍 워크플로 상세:  npx workflow show ${firstId}`);
-            console.log(`🔀 워크플로 실행:  npx workflow run start <id> --set key="value"`);
+            console.log(`🔍 Workflow details:  npx workflow show ${firstId}`);
+            console.log(`🔀 Run workflow:  npx workflow run start <id> --set key="value"`);
         }
         const listCtx = {
             commandId: 'workflow.list',
@@ -531,10 +561,180 @@ function cmdValidate(engine, target, jsonMode) {
     if (hasErrors)
         process.exit(1);
 }
+function repairChangeForOutput(change) {
+    return {
+        task_id: change.id,
+        kind: change.kind,
+        before: {
+            status: change.before.status,
+            error: change.before.error,
+            completed_at: change.before.completedAt,
+            duration_ms: change.before.durationMs,
+        },
+        after: {
+            status: change.after.status,
+            error: change.after.error,
+            completed_at: change.after.completedAt,
+            duration_ms: change.after.durationMs,
+        },
+        reason: change.reason,
+    };
+}
+function auditSnapshotChangeForOutput(change) {
+    return {
+        instance_id: change.instanceId,
+        before: change.before,
+        after: change.after,
+    };
+}
+function reportRepair(preview, mode, jsonMode, projectionErrors = []) {
+    const changes = preview.parentChanges.map(repairChangeForOutput);
+    const auditCardChanges = preview.auditSnapshotChanges.map(auditSnapshotChangeForOutput);
+    const errors = [...preview.errors, ...projectionErrors];
+    if (jsonMode) {
+        console.log(JSON.stringify({
+            success: true,
+            exec_id: preview.runId,
+            mode,
+            dry_run: mode === 'dry-run',
+            applied: mode === 'apply',
+            run_status: preview.runStatus,
+            changes,
+            audit_card_changes: auditCardChanges,
+            ...(errors.length > 0 ? { errors } : {}),
+        }, null, 2));
+        return;
+    }
+    console.log(`🔧 Workflow repair (${mode}): ${preview.runId}`);
+    console.log(`   Run status: ${preview.runStatus}`);
+    if (changes.length === 0 && auditCardChanges.length === 0) {
+        console.log('   No parent lifecycle changes needed.');
+    }
+    else {
+        for (const change of changes) {
+            console.log(`   ${mode === 'apply' ? 'Updated' : 'Would update'} ${change.task_id} (${change.kind}): ${change.before.status} → ${change.after.status}`);
+            console.log(`      Reason: ${change.reason}`);
+        }
+        for (const change of auditCardChanges) {
+            console.log(`   ${mode === 'apply' ? 'Updated' : 'Would update'} audit card ${change.instance_id}: ${change.before.phase ?? '(unknown)'} → ${change.after.phase}`);
+        }
+    }
+    for (const error of errors) {
+        console.error(`   Warning: ${error}`);
+    }
+}
+function validateRepairRun(run, execId) {
+    if (run.id !== execId) {
+        throw new Error(`Execution file ID mismatch: requested ${execId}, found ${run.id || '(missing)'}`);
+    }
+    if (!run.workflow_id || !run.workflow_file || !run.created_at || !run.updated_at
+        || typeof run.current_node !== 'string'
+        || !Array.isArray(run.completed_nodes)
+        || !run.state || typeof run.state !== 'object'
+        || !run.initial_state || typeof run.initial_state !== 'object') {
+        throw new Error(`Run "${execId}" is incomplete and cannot be repaired`);
+    }
+}
+function cmdRepair(rest, jsonMode, apply, dryRun) {
+    const execId = rest[0];
+    if (!execId) {
+        const msg = 'Usage: workflow repair <run-id> [--dry-run|--apply]';
+        if (jsonMode)
+            console.log(JSON.stringify({ success: false, error: msg }));
+        else
+            console.error(`❌ ${msg}`);
+        process.exit(1);
+    }
+    if (apply && dryRun) {
+        const msg = 'Choose either --dry-run or --apply, not both';
+        if (jsonMode)
+            console.log(JSON.stringify({ success: false, error: msg }));
+        else
+            console.error(`❌ ${msg}`);
+        process.exit(1);
+    }
+    const projectRoot = getProjectRoot();
+    const workspaceId = (0, sdk_1.hashWorkspaceId)(projectRoot);
+    const taskRepo = new repository_1.TaskRepository();
+    const mgr = new run_manager_1.RunManager(undefined, projectRoot);
+    const engine = new engine_1.WorkflowEngine();
+    let uiInstanceStore;
+    let readOnlyUiInstanceStore;
+    const resolveWorkflowSpec = (run) => resolveWorkflowSpecForRun(run, engine);
+    const getUiInstanceStore = () => {
+        uiInstanceStore ?? (uiInstanceStore = new sdk_1.UiInstanceStore(taskRepo.resolveDbPath()));
+        return uiInstanceStore;
+    };
+    const getReadOnlyUiInstanceStore = () => {
+        readOnlyUiInstanceStore ?? (readOnlyUiInstanceStore = (0, sdk_1.openUiInstanceReadStore)(taskRepo.resolveDbPath()));
+        return readOnlyUiInstanceStore;
+    };
+    const persistenceProjection = (0, workflow_persistence_1.createWorkflowPersistenceProjection)({
+        taskRepo,
+        workspaceId,
+        resolveWorkflowSpec,
+        getUiInstanceStore,
+    });
+    const persistencePreviewOptions = {
+        taskRepo,
+        workspaceId,
+        resolveWorkflowSpec,
+        getUiInstanceStore: getReadOnlyUiInstanceStore,
+    };
+    try {
+        const observed = mgr.readRun(execId);
+        if (!observed)
+            throw new Error(`Execution not found: ${execId}`);
+        validateRepairRun(observed, execId);
+        if (!(0, parent_task_sync_1.deriveWorkflowParentLifecycle)(observed)) {
+            throw new Error(`Run "${execId}" has an unsupported or insufficient persisted status: ${observed.status ?? 'pending'}`);
+        }
+        if (!apply) {
+            reportRepair((0, workflow_persistence_1.previewWorkflowPersistenceProjection)(persistencePreviewOptions, observed), 'dry-run', jsonMode);
+            return;
+        }
+        const result = mgr.withRunLock(execId, (latest) => {
+            validateRepairRun(latest, execId);
+            if (!(0, parent_task_sync_1.deriveWorkflowParentLifecycle)(latest)) {
+                throw new Error(`Run "${execId}" has an unsupported or insufficient persisted status: ${latest.status ?? 'pending'}`);
+            }
+            const preview = (0, workflow_persistence_1.previewWorkflowPersistenceProjection)(persistencePreviewOptions, latest);
+            const projection = persistenceProjection(latest);
+            return { preview, projection };
+        });
+        reportRepair(result.preview, 'apply', jsonMode, result.projection.errors);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (jsonMode)
+            console.log(JSON.stringify({ success: false, error: msg }));
+        else
+            console.error(`❌ ${msg}`);
+        process.exit(1);
+    }
+    finally {
+        uiInstanceStore?.close();
+        readOnlyUiInstanceStore?.close();
+    }
+}
 async function cmdRun(rest, rawArgs, jsonMode, engine) {
     const runSub = rest[0];
     const runArgs = rest.slice(1);
-    const mgr = new run_manager_1.RunManager();
+    const projectRoot = getProjectRoot();
+    const taskRepo = new repository_1.TaskRepository();
+    let uiInstanceStore;
+    const persistenceProjection = (0, workflow_persistence_1.createWorkflowPersistenceProjection)({
+        taskRepo,
+        workspaceId: (0, sdk_1.hashWorkspaceId)(projectRoot),
+        resolveWorkflowSpec: (run) => resolveWorkflowSpecForRun(run, engine),
+        getUiInstanceStore: () => {
+            uiInstanceStore ?? (uiInstanceStore = new sdk_1.UiInstanceStore(taskRepo.resolveDbPath()));
+            return uiInstanceStore;
+        },
+    });
+    const mgr = new run_manager_1.RunManager(undefined, projectRoot, {
+        onRunPersisted: persistenceProjection,
+    });
     const { paths } = getWorkflowConfig();
     switch (runSub) {
         case 'start': {
@@ -707,6 +907,7 @@ async function cmdRun(rest, rawArgs, jsonMode, engine) {
                 const run = noExec
                     ? mgr.moveNode(execId, nodeId)
                     : await mgr.executeNode(execId, nodeId);
+                const nodeStatus = getNodeResultStatus(run, nodeId, mgr.getNodeType(run.workflow_file, run.workflow_id, nodeId), noExec);
                 if (jsonMode) {
                     console.log(JSON.stringify({
                         success: true,
@@ -726,8 +927,8 @@ async function cmdRun(rest, rawArgs, jsonMode, engine) {
                             console.log(`   Completed: ${run.completed_nodes.join(' \u2192 ')}`);
                         }
                         console.log(`   Current: ${run.current_node}`);
-                        if (run.status) {
-                            console.log(`   Status: ${run.status}`);
+                        if (nodeStatus) {
+                            console.log(`   Status: ${nodeStatus}`);
                         }
                     }
                     let nextNode = null;
@@ -809,6 +1010,58 @@ async function cmdRun(rest, rawArgs, jsonMode, engine) {
             }
             break;
         }
+        case 'retry': {
+            const positional = runArgs.filter(a => !a.startsWith('--'));
+            const execId = positional[0];
+            if (!execId) {
+                const msg = 'Usage: workflow run retry <exec-id> [--no-run]';
+                if (jsonMode) {
+                    console.log(JSON.stringify({ success: false, error: msg }));
+                }
+                else {
+                    console.error(`❌ ${msg}`);
+                }
+                process.exit(1);
+            }
+            const noRun = rawArgs.includes('--no-run');
+            try {
+                const run = mgr.retry(execId, { autoRun: !noRun });
+                if (noRun) {
+                    if (jsonMode) {
+                        console.log(JSON.stringify({
+                            success: true,
+                            exec_id: run.id,
+                            current_node: run.current_node,
+                            retry_count: run.retry_count,
+                            status: run.status,
+                        }, null, 2));
+                    }
+                    else {
+                        console.log(`✅ Retry transition: ${execId}`);
+                        console.log(`   Resume node: ${run.current_node}`);
+                        console.log(`   Retry count: ${run.retry_count}`);
+                        console.log(`   (state transition only; run "workflow run auto ${execId}" to execute — re-runs the node, safe only if idempotent)`);
+                    }
+                }
+                else {
+                    const result = await mgr.runAuto(run.id);
+                    reportAutoResult(result, jsonMode);
+                    if (result.outcome === 'failed')
+                        process.exit(1);
+                }
+            }
+            catch (e) {
+                const msg = e.message;
+                if (jsonMode) {
+                    console.log(JSON.stringify({ success: false, error: msg }));
+                }
+                else {
+                    console.error(`❌ ${msg}`);
+                }
+                process.exit(1);
+            }
+            break;
+        }
         case 'list': {
             const runs = mgr.listRuns();
             if (jsonMode) {
@@ -871,7 +1124,7 @@ async function cmdRun(rest, rawArgs, jsonMode, engine) {
             break;
         }
         default: {
-            const msg = `Unknown run subcommand: ${runSub || '(none)'}\nUsage: workflow run <start|state|node|auto|reset|list> [args...]`;
+            const msg = `Unknown run subcommand: ${runSub || '(none)'}\nUsage: workflow run <start|state|node|auto|reset|retry|list> [args...]`;
             if (jsonMode) {
                 console.log(JSON.stringify({ success: false, error: msg }));
             }
@@ -884,7 +1137,7 @@ async function cmdRun(rest, rawArgs, jsonMode, engine) {
 }
 function reportAutoResult(result, jsonMode) {
     const { run, outcome, reason, executed } = result;
-    const status = run.status ?? (outcome === 'paused' ? 'paused' : 'running');
+    const status = run.status;
     if (jsonMode) {
         console.log(JSON.stringify({
             success: outcome !== 'failed',
@@ -1024,6 +1277,10 @@ async function main(inputArgs) {
             await cmdRun(rest, args, jsonMode, engine);
             break;
         }
+        case 'repair': {
+            cmdRepair(rest, jsonMode, !!options.apply, !!options['dry-run']);
+            break;
+        }
         case 'usage':
             showDetailedUsage();
             break;