@fractary/faber-cli 1.5.46 → 1.5.47

package/dist/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,iBAAiB,IAAI,OAAO,CA0J3C"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/fractary-faber-init.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,iBAAiB,IAAI,OAAO,CA0J3C"}

package/dist/commands/plan/index.js

@@ -24,7 +24,7 @@ export function createPlanCommand() {
         .option('--work-label <labels>', 'Comma-separated label filters (e.g., "workflow:etl,status:approved")')
         .option('--workflow <name>', 'Override workflow (default: read from issue "workflow:*" label)')
         .option('--autonomy <level>', 'Override autonomy level (guarded|autonomous)')
-        .option('--no-worktree', 'Skip worktree creation')
+        .option('--worktree', 'Create a git worktree for this workflow (overrides config)')
         .option('--no-branch', 'Skip branch creation')
         .option('--skip-confirm', 'Skip confirmation prompt (use with caution)')
         .option('--output <format>', 'Output format: text|json|yaml', 'text')
@@ -186,7 +186,7 @@ async function executePlanCommand(options) {
     const issuesWithWorkflows = await assignWorkflows(issues, availableWorkflows, options, outputFormat);
     // Step 3: Show confirmation prompt
     if (!options.skipConfirm) {
-        const confirmed = await showConfirmationPrompt(issuesWithWorkflows, config, outputFormat);
+        const confirmed = await showConfirmationPrompt(issuesWithWorkflows, config, options, outputFormat);
         if (!confirmed) {
             if (outputFormat === 'text') {
                 console.log(chalk.yellow('\n✖ Planning cancelled'));
@@ -306,24 +306,40 @@ async function assignWorkflows(issues, availableWorkflows, options, outputFormat
 /**
  * Show confirmation prompt before planning
  */
-async function showConfirmationPrompt(issues, config, outputFormat) {
+async function showConfirmationPrompt(issues, config, options, outputFormat) {
     if (outputFormat !== 'text') {
         return true; // Skip in JSON mode
     }
+    const createWorktree = shouldCreateWorktree(options, config);
     console.log(chalk.cyan('\n📋 Will plan workflows for the following issues:\n'));
     for (const issue of issues) {
         const { organization, project } = getRepoInfoFromConfig(config);
         const branch = `feature/${issue.number}`;
-        const worktree = `~/.claude-worktrees/${organization}-${project}-${issue.number}`;
         console.log(chalk.bold(`#${issue.number}: ${issue.title}`));
         console.log(chalk.gray(`  Workflow: ${issue.workflow}`));
         console.log(chalk.gray(`  Branch: ${branch}`));
-        console.log(chalk.gray(`  Worktree: ${worktree}`));
+        if (createWorktree) {
+            const worktree = `~/.claude-worktrees/${organization}-${project}-${issue.number}`;
+            console.log(chalk.gray(`  Worktree: ${worktree}`));
+        }
         console.log();
     }
     const response = await prompt('Proceed? [Y/n]: ');
     return !response || response.toLowerCase() === 'y' || response.toLowerCase() === 'yes';
 }
+/**
+ * Determine whether to create a worktree based on CLI flag and config
+ */
+function shouldCreateWorktree(options, config) {
+    // Explicit CLI flag always wins
+    if (options.worktree === true)
+        return true;
+    // Config setting is the default authority
+    if (config.worktree?.enabled === true)
+        return true;
+    // Default: no worktree
+    return false;
+}
 /**
  * Plan a single issue
  */
@@ -331,6 +347,7 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
     const { organization, project } = getRepoInfoFromConfig(config);
     const branch = `feature/${issue.number}`;
     const worktree = `~/.claude-worktrees/${organization}-${project}-${issue.number}`;
+    const createWorktree = shouldCreateWorktree(options, config);
     // Create branch without checking it out (so it won't conflict with worktree creation)
     if (!options.noBranch) {
         if (outputFormat === 'text') {
@@ -348,9 +365,9 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
             // Branch might already exist, that's ok
         }
     }
-    // Create worktree
-    let worktreePath = worktree;
-    if (!options.noWorktree) {
+    // Create worktree (only when explicitly opted in via flag or config)
+    let worktreePath = createWorktree ? worktree : process.cwd();
+    if (createWorktree) {
         if (outputFormat === 'text') {
             console.log(chalk.gray(`  → Creating worktree: ${worktree}...`));
             process.stdout.write(''); // Force flush
@@ -393,8 +410,8 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
             // Non-fatal: if cleanup fails, workflow-run will handle conflict detection
         }
     }
-    // Check for existing plan in worktree (skip if found, unless --force-new)
-    if (!options.forceNew && !options.noWorktree) {
+    // Check for existing plan (skip if found, unless --force-new)
+    if (!options.forceNew) {
         const runsDir = path.join(worktreePath, '.fractary', 'faber', 'runs');
         try {
             const entries = await fs.readdir(runsDir);
@@ -434,8 +451,8 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
         plan.autonomy = options.autonomy;
     }
     const planId = plan.id;
-    // Write plan to worktree
-    if (!options.noWorktree) {
+    // Write plan to worktree (or project root when no worktree)
+    {
         // Validate plan ID format (prevent path traversal via malicious plan IDs)
         validatePlanId(planId);
         const runDir = getRunDir(planId, worktreePath);
@@ -544,7 +561,7 @@ function generatePlanComment(plan, workflow, worktreePath, planId, issueNumber)
     comment += `cd ${worktreePath}\n`;
     comment += `claude\n`;
     comment += `# Then in Claude Code:\n`;
-    comment += `/fractary-faber:workflow-run ${issueNumber}\n`;
+    comment += `/fractary-faber-workflow-run ${issueNumber}\n`;
     comment += `\`\`\`\n`;
     return comment;
 }
@@ -575,7 +592,7 @@ function outputTextSummary(results) {
             console.log();
             console.log(chalk.cyan('      To execute:'));
             console.log(chalk.gray(`        cd ${result.worktree} && claude`));
-            console.log(chalk.gray(`        /fractary-faber:workflow-run ${result.issue.number}`));
+            console.log(chalk.gray(`        /fractary-faber-workflow-run ${result.issue.number}`));
             console.log();
         });
     }

package/dist/commands/spec/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/spec/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAc3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/fractary-faber-spec/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAc3C"}

package/dist/commands/workflow/index.d.ts

@@ -40,6 +40,19 @@ export declare function createWorkflowUpdateCommand(): Command;
  * Create the workflow-inspect command
  */
 export declare function createWorkflowInspectCommand(): Command;
+/**
+ * Create the workflow-resolve command.
+ *
+ * Resolves a workflow with full inheritance chain merging via WorkflowResolver.
+ * Unlike workflow-inspect (which only looks in project-local registry),
+ * workflow-resolve also searches bundled plugin defaults — making it the
+ * CLI equivalent of merge-workflows.sh and the correct tool for agents and
+ * skills that need a fully-merged workflow definition.
+ *
+ * Works identically in Claude Code and pi installs: WorkflowResolver uses
+ * __dirname to locate bundled workflows without any environment configuration.
+ */
+export declare function createWorkflowResolveCommand(): Command;
 /**
  * Create the workflow-debug command
  */
@@ -52,4 +65,8 @@ export declare function createBatchPlanCommand(): Command;
  * Create the workflow-batch-run command
  */
 export declare function createBatchRunCommand(): Command;
+/**
+ * Create the workflow-execute command (multi-model CLI-native execution)
+ */
+export declare function createWorkflowExecuteCommand(): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAsJ1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAiF7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAoB5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA8B9C;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAoCrD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CA4BrD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CA0CtD;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAkDpD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAehD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAgB/C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAsJ1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAiF7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAoB5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA8B9C;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAoCrD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CA4BrD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CA0CtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAkDtD;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAkDpD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAehD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAgB/C;AAgYD;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAuHtD"}

package/dist/commands/workflow/index.js

@@ -5,7 +5,7 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { FaberWorkflow, StateManager, createWorkflow, updateWorkflow, inspectWorkflow, debugWorkflow, } from '@fractary/faber';
+import { FaberWorkflow, StateManager, createWorkflow, updateWorkflow, inspectWorkflow, debugWorkflow, WorkflowResolver, ExecutorRegistry, WorkflowExecutor, } from '@fractary/faber';
 import { parsePositiveInteger } from '../../utils/validation.js';
 /**
  * Create the workflow-run command
@@ -477,6 +477,67 @@ export function createWorkflowInspectCommand() {
         }
     });
 }
+/**
+ * Create the workflow-resolve command.
+ *
+ * Resolves a workflow with full inheritance chain merging via WorkflowResolver.
+ * Unlike workflow-inspect (which only looks in project-local registry),
+ * workflow-resolve also searches bundled plugin defaults — making it the
+ * CLI equivalent of merge-workflows.sh and the correct tool for agents and
+ * skills that need a fully-merged workflow definition.
+ *
+ * Works identically in Claude Code and pi installs: WorkflowResolver uses
+ * __dirname to locate bundled workflows without any environment configuration.
+ */
+export function createWorkflowResolveCommand() {
+    return new Command('workflow-resolve')
+        .description('Resolve a workflow with full inheritance chain merging (includes bundled plugin defaults)')
+        .argument('<id>', 'Workflow ID to resolve (e.g. "core", "default", "project:my-workflow")')
+        .option('--project-root <path>', 'Project root directory (default: cwd)')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        try {
+            const resolver = new WorkflowResolver({
+                projectRoot: options.projectRoot,
+            });
+            const workflow = await resolver.resolveWorkflow(id);
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'success', workflow }, null, 2));
+            }
+            else {
+                console.log(chalk.bold(`Workflow: ${workflow.id}`));
+                if (workflow.description) {
+                    console.log(`  Description: ${workflow.description}`);
+                }
+                console.log(`  Inheritance chain: ${workflow.inheritance_chain.join(' → ')}`);
+                if (workflow.skipped_steps?.length) {
+                    console.log(`  Skipped steps: ${workflow.skipped_steps.join(', ')}`);
+                }
+                console.log();
+                for (const [phase, def] of Object.entries(workflow.phases)) {
+                    const steps = def.steps ?? [];
+                    const enabled = def.enabled !== false;
+                    console.log(chalk.cyan(`  ${phase}`), enabled ? '' : chalk.gray('(disabled)'), chalk.gray(`${steps.length} steps`));
+                }
+            }
+        }
+        catch (error) {
+            if (options.json) {
+                const msg = error instanceof Error ? error.message : String(error);
+                const paths = error.searchedPaths;
+                console.error(JSON.stringify({
+                    status: 'failure',
+                    message: msg,
+                    errors: paths ? [`Searched: ${paths.join(', ')}`] : [msg],
+                }));
+            }
+            else {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+            }
+            process.exit(1);
+        }
+    });
+}
 /**
  * Create the workflow-debug command
  */
@@ -708,7 +769,7 @@ async function executeBatchPlanCommand(options) {
         console.log(chalk.white(`  fractary-faber workflow-batch-run --batch ${batchId} --autonomous`));
         console.log('');
         console.log(chalk.cyan('Or in Claude Code:'));
-        console.log(chalk.white(`  /fractary-faber:workflow-batch-run --batch ${batchId} --autonomous`));
+        console.log(chalk.white(`  /fractary-faber-workflow-batch-run --batch ${batchId} --autonomous`));
     }
 }
 async function executeBatchRunCommand(options) {
@@ -872,6 +933,117 @@ async function executeBatchRunCommand(options) {
         process.exit(1);
     }
 }
+/**
+ * Create the workflow-execute command (multi-model CLI-native execution)
+ */
+export function createWorkflowExecuteCommand() {
+    return new Command('workflow-execute')
+        .description('Execute a workflow using the multi-model executor framework (CLI-native, no Claude Code required)')
+        .argument('<plan-path>', 'Path to plan.json file')
+        .option('--model <model>', 'Default model for steps without an explicit executor (default: claude-sonnet-4-6-20250514)')
+        .option('--phase <phases>', 'Execute only specified phase(s) — comma-separated')
+        .option('--step <step-id>', 'Execute only a specific step')
+        .option('--json', 'Output as JSON')
+        .action(async (planPath, options) => {
+        try {
+            const fs = await import('fs/promises');
+            const path = await import('path');
+            // Load plan
+            const resolvedPath = path.resolve(planPath);
+            const planContent = await fs.readFile(resolvedPath, 'utf-8');
+            const plan = JSON.parse(planContent);
+            if (!plan.workflow?.phases) {
+                throw new Error('Invalid plan: missing workflow.phases');
+            }
+            // Create executor registry with defaults
+            const registry = ExecutorRegistry.createDefault();
+            // Override default model if specified
+            const workflowExecutor = plan.workflow.executor || (options.model ? {
+                provider: 'claude',
+                model: options.model,
+            } : undefined);
+            // Create workflow executor
+            const executor = new WorkflowExecutor(registry);
+            // Parse options
+            const phasesToRun = options.phase?.split(',').map((p) => p.trim()) ?? null;
+            // Extract work ID from plan
+            const workId = plan.source?.work_id || plan.items?.[0]?.work_id || 'unknown';
+            const issue = plan.items?.[0]?.issue;
+            if (!options.json) {
+                console.log(chalk.blue.bold('FABER Multi-Model Workflow Execution'));
+                console.log(chalk.gray('═'.repeat(50)));
+                console.log(chalk.gray(`Plan: ${resolvedPath}`));
+                console.log(chalk.gray(`Work ID: ${workId}`));
+                console.log(chalk.gray(`Workflow: ${plan.workflow.id}`));
+                if (workflowExecutor) {
+                    console.log(chalk.gray(`Default executor: ${workflowExecutor.provider}${workflowExecutor.model ? ` (${workflowExecutor.model})` : ''}`));
+                }
+                console.log('');
+            }
+            // Execute
+            const result = await executor.execute({
+                phases: plan.workflow.phases,
+                executor: workflowExecutor,
+                phase_executors: plan.workflow.phase_executors,
+                result_handling: plan.workflow.result_handling,
+            }, {
+                workId,
+                issue: issue ? { number: issue.number, title: issue.title, body: '' } : undefined,
+                workingDirectory: path.dirname(resolvedPath),
+                phasesToRun: phasesToRun || undefined,
+                stepToRun: options.step || null,
+                onPhaseStart: (phase) => {
+                    if (!options.json) {
+                        console.log(chalk.cyan(`\n→ Phase: ${phase.toUpperCase()}`));
+                    }
+                },
+                onStepStart: (phase, step, index, total) => {
+                    if (!options.json) {
+                        const executor = step.executor;
+                        const providerTag = executor
+                            ? chalk.magenta(`[${executor.provider}${executor.model ? `:${executor.model}` : ''}]`)
+                            : chalk.gray('[default]');
+                        console.log(chalk.gray(`  [${index + 1}/${total}] ${step.name} ${providerTag}`));
+                    }
+                },
+                onStepComplete: (_phase, step, stepResult) => {
+                    if (!options.json) {
+                        const icon = stepResult.status === 'success' ? chalk.green('✓') :
+                            stepResult.status === 'warning' ? chalk.yellow('⚠') :
+                                chalk.red('✗');
+                        console.log(`  ${icon} ${step.id} (${stepResult.metadata.duration_ms}ms)`);
+                        if (stepResult.metadata.tokens_used) {
+                            console.log(chalk.gray(`    tokens: ${stepResult.metadata.tokens_used.input}→${stepResult.metadata.tokens_used.output}`));
+                        }
+                    }
+                },
+                onPhaseComplete: (phase, status) => {
+                    if (!options.json) {
+                        const icon = status === 'completed' ? chalk.green('✓') :
+                            status === 'skipped' ? chalk.gray('⏭') :
+                                chalk.red('✗');
+                        console.log(`  ${icon} Phase ${phase} ${status}`);
+                    }
+                },
+            });
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'success', data: result }, null, 2));
+            }
+            else {
+                console.log(chalk.gray('\n' + '═'.repeat(50)));
+                const statusIcon = result.status === 'completed' ? chalk.green('✓') : chalk.red('✗');
+                console.log(`${statusIcon} Workflow ${result.status} (${result.duration_ms}ms)`);
+                console.log(chalk.gray(`  Steps: ${result.steps_completed}/${result.steps_total}`));
+            }
+            if (result.status === 'failed') {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
 // Helper functions
 function getStateColor(state) {
     switch (state) {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAwDxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CA0DxC"}

package/dist/index.js

@@ -10,7 +10,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { createRunCommand, createStatusCommand, createResumeCommand, createPauseCommand, createRecoverCommand, createCleanupCommand, createWorkflowCreateCommand, createWorkflowUpdateCommand, createWorkflowInspectCommand, createWorkflowDebugCommand, createBatchPlanCommand, createBatchRunCommand } from './commands/workflow/index.js';
+import { createRunCommand, createStatusCommand, createResumeCommand, createPauseCommand, createRecoverCommand, createCleanupCommand, createWorkflowCreateCommand, createWorkflowUpdateCommand, createWorkflowInspectCommand, createWorkflowResolveCommand, createWorkflowDebugCommand, createBatchPlanCommand, createBatchRunCommand, createWorkflowExecuteCommand } from './commands/workflow/index.js';
 import { createSessionLoadCommand, createSessionSaveCommand } from './commands/session.js';
 import { createWorkCommand } from './commands/work/index.js';
 import { createRepoCommand } from './commands/repo/index.js';
@@ -51,10 +51,12 @@ export function createFaberCLI() {
     program.addCommand(createCleanupCommand()); // workflow-cleanup
     program.addCommand(createWorkflowCreateCommand()); // workflow-create
     program.addCommand(createWorkflowUpdateCommand()); // workflow-update
-    program.addCommand(createWorkflowInspectCommand()); // workflow-inspect
+    program.addCommand(createWorkflowInspectCommand()); // workflow-inspect (project-local registry)
+    program.addCommand(createWorkflowResolveCommand()); // workflow-resolve (full inheritance + bundled defaults)
     program.addCommand(createWorkflowDebugCommand()); // workflow-debug
     program.addCommand(createBatchPlanCommand()); // workflow-batch-plan
     program.addCommand(createBatchRunCommand()); // workflow-batch-run
+    program.addCommand(createWorkflowExecuteCommand()); // workflow-execute (multi-model CLI-native)
     program.addCommand(createSessionLoadCommand()); // session-load
     program.addCommand(createSessionSaveCommand()); // session-save
     // Subcommand trees

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fractary/faber-cli",
-  "version": "1.5.46",
+  "version": "1.5.47",
   "description": "FABER CLI - Command-line interface for FABER development toolkit",
   "main": "dist/index.js",
   "bin": {

package/schemas/plan.schema.json

@@ -91,7 +91,7 @@
       "properties": {
         "id": {
           "type": "string",
-          "description": "Workflow identifier (e.g., fractary-faber:default, dataset-create)"
+          "description": "Workflow identifier (e.g., fractary-faber-default, dataset-create)"
         },
         "resolved_at": {
           "type": "string",