@fractary/faber-cli 1.5.25 → 1.5.27

package/README.md

@@ -52,7 +52,6 @@ See [GitHub App Setup Guide](../docs/github-app-setup.md) for detailed manual in
 ### 3. Initialize a FABER project
 
 ```bash
-fractary-faber configure
 fractary-faber config init
 fractary-faber config init --autonomy guarded
 ```

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

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

package/dist/commands/plan/index.js

@@ -10,6 +10,7 @@ import { RepoClient } from '../../lib/repo-client.js';
 import { ConfigManager } from '../../lib/config.js';
 import { prompt } from '../../utils/prompt.js';
 import { validateWorkIds, validateLabels, validateWorkflowName, validatePlanId, } from '../../utils/validation.js';
+import { getRunDir, getPlanPath, getActiveRunIdPath } from '@fractary/faber';
 import fs from 'fs/promises';
 import path from 'path';
 /**
@@ -323,7 +324,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}`;
-    // Generate plan via Anthropic API
+    // Generate deterministic plan from resolved workflow
     if (outputFormat === 'text') {
         console.log(chalk.gray('  → Generating plan...'));
         process.stdout.write(''); // Force flush
@@ -334,7 +335,7 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
         issueDescription: issue.description,
         issueNumber: issue.number,
     });
-    const planId = plan.plan_id;
+    const planId = plan.id;
     // Create branch without checking it out (so it won't conflict with worktree creation)
     if (!options.noBranch) {
         if (outputFormat === 'text') {
@@ -386,17 +387,24 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
                 throw error;
             }
         }
+        // Clean up worktree-local state that may have been copied from source branch.
+        // .active-run-id tracks the active run in a specific worktree and should not
+        // carry over to new worktrees (causes false conflict detection in workflow-run).
+        try {
+            const activeRunIdInWorktree = getActiveRunIdPath(worktreePath);
+            await fs.unlink(activeRunIdInWorktree).catch(() => { });
+        }
+        catch {
+            // Non-fatal: if cleanup fails, workflow-run will handle conflict detection
+        }
     }
     // Write plan to worktree
     if (!options.noWorktree) {
         // Validate plan ID format (prevent path traversal via malicious plan IDs)
         validatePlanId(planId);
-        const planDir = path.join(worktreePath, '.fractary', 'plans');
-        await fs.mkdir(planDir, { recursive: true });
-        // Construct and validate path
-        const planPath = path.join(planDir, `${planId}.json`);
-        // Note: path.join automatically normalizes and prevents basic traversal,
-        // but we validate the plan ID format as an additional layer of defense
+        const runDir = getRunDir(planId, worktreePath);
+        await fs.mkdir(runDir, { recursive: true });
+        const planPath = getPlanPath(planId, worktreePath);
         await fs.writeFile(planPath, JSON.stringify(plan, null, 2));
         if (outputFormat === 'text') {
             console.log(chalk.gray(`  → Plan written to ${planPath}`));
@@ -404,33 +412,33 @@ async function planSingleIssue(issue, config, repoClient, anthropicClient, optio
     }
     // Generate detailed comment for GitHub issue
     const planSummary = generatePlanComment(plan, issue.workflow, worktreePath, planId, issue.number);
-    // Update GitHub issue with plan_id
+    // Update GitHub issue: post comment, then try to add label separately
+    // (posting comment and adding label in a single updateIssue call caused
+    // duplicate comments when the label didn't exist, because the comment was
+    // already created before addLabels failed, and the retry re-posted it)
     if (outputFormat === 'text') {
         console.log(chalk.gray(`  → Updating GitHub issue...`));
     }
+    // Post comment first (essential operation)
+    await repoClient.updateIssue({
+        id: issue.number.toString(),
+        comment: planSummary,
+    });
+    // Try to ensure faber:planned label exists, create if needed (non-fatal)
     try {
+        const { labelExists, createLabel } = await import('../../utils/labels.js');
+        const exists = await labelExists('faber:planned');
+        if (!exists) {
+            await createLabel({ name: 'faber:planned', description: 'FABER workflow planned', color: '0e8a16' });
+        }
         await repoClient.updateIssue({
             id: issue.number.toString(),
-            comment: planSummary,
             addLabel: 'faber:planned',
         });
     }
     catch (error) {
-        // If label doesn't exist, just add comment without label
-        if (error instanceof Error &&
-            (error.message.includes('not found') ||
-                error.message.includes('faber:planned') ||
-                error.message.includes('--add-label'))) {
-            if (outputFormat === 'text') {
-                console.log(chalk.yellow(`  ⚠️  Label 'faber:planned' not found, adding comment only`));
-            }
-            await repoClient.updateIssue({
-                id: issue.number.toString(),
-                comment: planSummary,
-            });
-        }
-        else {
-            throw error;
+        if (outputFormat === 'text') {
+            console.log(chalk.yellow(`  ⚠️  Could not add 'faber:planned' label: ${error instanceof Error ? error.message : 'Unknown error'}`));
         }
     }
     if (outputFormat === 'text') {
@@ -450,43 +458,47 @@ function generatePlanComment(plan, workflow, worktreePath, planId, issueNumber)
     let comment = `🤖 **Workflow Plan Created**\n\n`;
     comment += `**Plan ID:** \`${planId}\`\n`;
     comment += `**Workflow:** \`${workflow}\`\n`;
-    // Add workflow inheritance info if available
-    if (plan.workflow_config?.inherits_from) {
-        comment += `**Inherits from:** \`${plan.workflow_config.inherits_from}\`\n`;
+    // Add workflow inheritance chain if available
+    if (plan.workflow?.inheritance_chain?.length > 1) {
+        comment += `**Inheritance:** ${plan.workflow.inheritance_chain.join(' → ')}\n`;
     }
+    comment += `**Autonomy:** \`${plan.autonomy || 'guarded'}\`\n`;
     comment += `\n---\n\n`;
-    // Add plan summary by phase
-    if (plan.phases && Array.isArray(plan.phases)) {
+    // Add plan summary by phase (workflow.phases is an object keyed by phase name)
+    if (plan.workflow?.phases) {
         comment += `### Workflow Phases\n\n`;
-        plan.phases.forEach((phase, index) => {
-            comment += `**${index + 1}. ${phase.name || phase.phase}**\n\n`;
-            // Show phase description if available
+        const phaseOrder = ['frame', 'architect', 'build', 'evaluate', 'release'];
+        phaseOrder.forEach((phaseName, index) => {
+            const phase = plan.workflow.phases[phaseName];
+            if (!phase)
+                return;
+            const enabled = phase.enabled !== false;
+            const statusIcon = enabled ? '✅' : '⏭️';
+            comment += `**${index + 1}. ${phaseName}** ${statusIcon}${!enabled ? ' *(skipped)*' : ''}\n\n`;
             if (phase.description) {
                 comment += `*${phase.description}*\n\n`;
             }
-            // Show steps/tasks
-            if (phase.steps && Array.isArray(phase.steps)) {
-                phase.steps.forEach((step) => {
-                    const action = step.action || step.name || step.description || step;
-                    comment += `  - **${action}**`;
-                    if (step.details) {
-                        comment += `: ${step.details}`;
+            // Show all step arrays: pre_steps, steps, post_steps
+            const allSteps = [
+                ...(phase.pre_steps || []),
+                ...(phase.steps || []),
+                ...(phase.post_steps || []),
+            ];
+            if (allSteps.length > 0) {
+                allSteps.forEach((step) => {
+                    comment += `  - **${step.id}**`;
+                    if (step.name) {
+                        comment += ` — ${step.name}`;
                     }
                     comment += `\n`;
                 });
             }
-            else if (phase.tasks && Array.isArray(phase.tasks)) {
-                phase.tasks.forEach((task) => {
-                    const taskDesc = task.description || task.name || task;
-                    comment += `  - ${taskDesc}\n`;
-                });
-            }
             comment += `\n`;
         });
     }
     comment += `---\n\n`;
     comment += `### Plan Location\n\n`;
-    const planPath = `${worktreePath}/.fractary/plans/${planId}.json`;
+    const planPath = `${worktreePath}/.fractary/faber/runs/${planId}/plan.json`;
     comment += `| File | Path |\n`;
     comment += `|------|------|\n`;
     comment += `| Plan | \`${planPath}\` |\n\n`;

package/dist/lib/anthropic-client.d.ts

@@ -1,8 +1,15 @@
 /**
- * Anthropic API Client
+ * Plan Builder (formerly Anthropic Client)
  *
- * Generates workflow plans via Claude API
+ * Generates deterministic workflow plans from resolved workflow configurations.
+ * The plan structure is built programmatically from the resolved workflow —
+ * no LLM call is needed because the plan is a direct representation of the
+ * workflow definition with issue/branch metadata attached.
+ *
+ * This aligns the CLI plan format with the faber-planner agent format,
+ * ensuring workflow-run can consume plans from either source.
  */
+import { type ResolvedWorkflow } from '@fractary/faber';
 import type { LoadedFaberConfig } from '../types/config.js';
 interface GeneratePlanInput {
     workflow: string;
@@ -10,27 +17,70 @@ interface GeneratePlanInput {
     issueDescription: string;
     issueNumber: number;
 }
+export interface WorkflowPlanItem {
+    target: string;
+    work_id: string;
+    planning_mode: 'work_id';
+    issue: {
+        number: number;
+        title: string;
+        url: string;
+    };
+    target_context: null;
+    branch: {
+        name: string;
+        status: 'new' | 'ready' | 'resume';
+    };
+    worktree: string | null;
+}
 export interface WorkflowPlan {
-    plan_id: string;
+    id: string;
+    created: string;
     created_by: string;
     cli_version: string;
-    created_at: string;
-    issue: {
-        source: string;
+    metadata: {
+        org: string;
+        project: string;
+        subproject: string;
+        year: string;
+        month: string;
+        day: string;
+        hour: string;
+        minute: string;
+        second: string;
+    };
+    source: {
+        input: string;
+        work_id: string;
+        planning_mode: 'work_id';
+        target_match: null;
+        expanded_from: null;
+    };
+    workflow: {
         id: string;
-        url: string;
+        resolved_at: string;
+        inheritance_chain: string[];
+        phases: ResolvedWorkflow['phases'];
+    };
+    autonomy: string;
+    phases_to_run: string[] | null;
+    step_to_run: string | null;
+    additional_instructions: string | null;
+    items: WorkflowPlanItem[];
+    execution: {
+        mode: 'sequential' | 'parallel';
+        max_concurrent: number;
+        status: 'pending';
+        started_at: null;
+        completed_at: null;
+        results: never[];
     };
-    branch: string;
-    worktree: string;
-    workflow: string;
-    phases: any[];
     [key: string]: any;
 }
 /**
- * Anthropic API Client
+ * Plan Builder (exported as AnthropicClient for backward compatibility)
  */
 export declare class AnthropicClient {
-    private client;
     private config;
     private git;
     private ajv;
@@ -45,17 +95,13 @@ export declare class AnthropicClient {
      */
     private validatePlan;
     /**
-     * Generate workflow plan via Claude API
+     * Generate deterministic workflow plan.
+     *
+     * Builds the plan structure directly from the resolved workflow configuration,
+     * matching the format produced by the faber-planner agent. No LLM call is needed
+     * because the plan is a direct representation of the workflow definition.
      */
     generatePlan(input: GeneratePlanInput): Promise<WorkflowPlan>;
-    /**
-     * Construct planning prompt for Claude
-     */
-    private constructPlanningPrompt;
-    /**
-     * Extract JSON from Claude response
-     */
-    private extractJsonFromResponse;
     /**
      * Extract repository organization and project name using SDK Git class
      */

package/dist/lib/anthropic-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-client.d.ts","sourceRoot":"","sources":["../../src/lib/anthropic-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,EAAE,EAAE,MAAM,CAAC;QACX,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,GAAG,EAAE,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,UAAU,CAAM;gBAEZ,MAAM,EAAE,iBAAiB;IAiBrC;;OAEG;YACW,cAAc;IAiB5B;;OAEG;IACH,OAAO,CAAC,YAAY;IAepB;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC;IA8DnE;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqD/B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;YACW,eAAe;CAqB9B"}
+{"version":3,"file":"anthropic-client.d.ts","sourceRoot":"","sources":["../../src/lib/anthropic-client.ts"],"names":[],"mappings":"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"}

package/dist/lib/anthropic-client.js

@@ -1,50 +1,44 @@
 /**
- * Anthropic API Client
+ * Plan Builder (formerly Anthropic Client)
  *
- * Generates workflow plans via Claude API
+ * Generates deterministic workflow plans from resolved workflow configurations.
+ * The plan structure is built programmatically from the resolved workflow —
+ * no LLM call is needed because the plan is a direct representation of the
+ * workflow definition with issue/branch metadata attached.
+ *
+ * This aligns the CLI plan format with the faber-planner agent format,
+ * ensuring workflow-run can consume plans from either source.
  */
-import Anthropic from '@anthropic-ai/sdk';
 import Ajv from 'ajv';
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { Git, WorkflowResolver } from '@fractary/faber';
-import { validateJsonSize } from '../utils/validation.js';
+import { slugify } from '../utils/validation.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
- * Anthropic API Client
+ * Plan Builder (exported as AnthropicClient for backward compatibility)
  */
 export class AnthropicClient {
     constructor(config) {
         this.config = config;
         this.git = new Git();
-        // validateFormats: false suppresses warnings about unknown formats (uri, date-time)
-        // These formats are used for documentation, not strict validation
         this.ajv = new Ajv({ strict: false, validateFormats: false });
-        const apiKey = config.anthropic?.api_key;
-        if (!apiKey) {
-            throw new Error('Anthropic API key not found. Set ANTHROPIC_API_KEY environment variable.');
-        }
-        this.client = new Anthropic({
-            apiKey,
-        });
     }
     /**
      * Load plan JSON schema for validation
      */
     async loadPlanSchema() {
         if (this.planSchema) {
-            return; // Already loaded
+            return;
         }
         try {
-            // Schema bundled with CLI package (cli/schemas/plan.schema.json)
             const schemaPath = path.resolve(__dirname, '../../schemas/plan.schema.json');
             const schemaContent = await fs.readFile(schemaPath, 'utf8');
             this.planSchema = JSON.parse(schemaContent);
         }
         catch (error) {
-            // Schema not found or invalid - log warning but don't fail
             console.warn('Warning: Could not load plan schema for validation:', error instanceof Error ? error.message : 'Unknown error');
             this.planSchema = null;
         }
@@ -54,7 +48,6 @@ export class AnthropicClient {
      */
     validatePlan(plan) {
         if (!this.planSchema) {
-            // Schema not loaded - skip validation
             return;
         }
         const validate = this.ajv.compile(this.planSchema);
@@ -65,137 +58,99 @@ export class AnthropicClient {
         }
     }
     /**
-     * Generate workflow plan via Claude API
+     * Generate deterministic workflow plan.
+     *
+     * Builds the plan structure directly from the resolved workflow configuration,
+     * matching the format produced by the faber-planner agent. No LLM call is needed
+     * because the plan is a direct representation of the workflow definition.
      */
     async generatePlan(input) {
-        // Load plan schema for validation
         await this.loadPlanSchema();
         // Resolve workflow with inheritance (uses SDK WorkflowResolver)
         const resolver = new WorkflowResolver({ projectRoot: process.cwd() });
         const workflowConfig = await resolver.resolveWorkflow(input.workflow);
-        // Generate plan ID
-        const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z/, '').replace('T', '-');
-        const planId = `fractary-faber-${input.issueNumber}-${timestamp}`;
-        // Construct prompt for Claude
-        const prompt = this.constructPlanningPrompt(input, workflowConfig);
-        // Call Claude API
-        const response = await this.client.messages.create({
-            model: 'claude-sonnet-4-5-20250929',
-            max_tokens: 8192,
-            messages: [
-                {
-                    role: 'user',
-                    content: prompt,
-                },
-            ],
-        });
-        // Extract plan JSON from response
-        const content = response.content[0];
-        if (content.type !== 'text') {
-            throw new Error('Unexpected response type from Claude API');
-        }
-        // Validate response size (prevent DoS)
-        validateJsonSize(content.text, 1024 * 1024); // 1MB limit
-        const planJson = this.extractJsonFromResponse(content.text);
-        // Add metadata
+        // Extract repo info
         const { organization, project } = await this.extractRepoInfo();
+        // Generate plan ID matching faber-planner format: {org}-{project}-{subproject}-{timestamp}
+        const now = new Date();
+        const year = now.getFullYear().toString();
+        const month = String(now.getMonth() + 1).padStart(2, '0');
+        const day = String(now.getDate()).padStart(2, '0');
+        const hour = String(now.getHours()).padStart(2, '0');
+        const minute = String(now.getMinutes()).padStart(2, '0');
+        const second = String(now.getSeconds()).padStart(2, '0');
+        const timestamp = `${year}${month}${day}-${hour}${minute}${second}`;
+        const subproject = `issue-${input.issueNumber}`;
+        const planId = `${slugify(organization)}-${slugify(project)}-${input.issueNumber}-${timestamp}`;
+        // Build the plan deterministically — no LLM call needed
         const plan = {
-            ...planJson,
-            plan_id: planId,
+            id: planId,
+            created: now.toISOString(),
             created_by: 'cli',
             cli_version: '1.3.2',
-            created_at: new Date().toISOString(),
-            issue: {
-                source: 'github',
-                id: input.issueNumber.toString(),
-                url: `https://github.com/${organization}/${project}/issues/${input.issueNumber}`,
+            metadata: {
+                org: organization,
+                project,
+                subproject,
+                year,
+                month,
+                day,
+                hour,
+                minute,
+                second,
+            },
+            source: {
+                input: `--work-id ${input.issueNumber}`,
+                work_id: input.issueNumber.toString(),
+                planning_mode: 'work_id',
+                target_match: null,
+                expanded_from: null,
+            },
+            workflow: {
+                id: workflowConfig.id,
+                resolved_at: now.toISOString(),
+                inheritance_chain: workflowConfig.inheritance_chain,
+                phases: workflowConfig.phases,
+            },
+            autonomy: workflowConfig.autonomy?.level || 'guarded',
+            phases_to_run: null,
+            step_to_run: null,
+            additional_instructions: null,
+            items: [{
+                    target: subproject,
+                    work_id: input.issueNumber.toString(),
+                    planning_mode: 'work_id',
+                    issue: {
+                        number: input.issueNumber,
+                        title: input.issueTitle,
+                        url: `https://github.com/${organization}/${project}/issues/${input.issueNumber}`,
+                    },
+                    target_context: null,
+                    branch: {
+                        name: `feat/${input.issueNumber}`,
+                        status: 'new',
+                    },
+                    worktree: null,
+                }],
+            execution: {
+                mode: 'sequential',
+                max_concurrent: 1,
+                status: 'pending',
+                started_at: null,
+                completed_at: null,
+                results: [],
             },
-            branch: `feature/${input.issueNumber}`,
-            worktree: `~/.claude-worktrees/${organization}-${project}-${input.issueNumber}`,
-            workflow: input.workflow,
         };
         // Validate plan against schema
         this.validatePlan(plan);
         return plan;
     }
-    /**
-     * Construct planning prompt for Claude
-     */
-    constructPlanningPrompt(input, workflowConfig) {
-        return `You are a workflow planning assistant for the FABER system. Your task is to generate a structured workflow plan based on the provided issue and workflow configuration.
-
-**Issue Information:**
-- Number: #${input.issueNumber}
-- Title: ${input.issueTitle}
-- Description: ${input.issueDescription}
-
-**Workflow Type:** ${input.workflow}
-
-**Workflow Configuration:**
-${JSON.stringify(workflowConfig, null, 2)}
-
-**Your Task:**
-Generate a complete workflow plan that includes:
-1. All phases from the workflow configuration
-2. Specific steps for each phase based on the issue requirements
-3. Success criteria for each phase
-4. Estimated complexity
-
-**Output Format:**
-Return ONLY a valid JSON object with the following structure:
-
-\`\`\`json
-{
-  "phases": [
-    {
-      "phase": "phase_name",
-      "description": "What this phase accomplishes",
-      "steps": [
-        {
-          "action": "specific action to take",
-          "details": "additional context or requirements"
-        }
-      ],
-      "success_criteria": [
-        "criterion 1",
-        "criterion 2"
-      ],
-      "complexity": "low|medium|high"
-    }
-  ],
-  "overall_complexity": "low|medium|high",
-  "estimated_phases": 4,
-  "special_considerations": [
-    "Any special notes or warnings"
-  ]
-}
-\`\`\`
-
-Generate the plan now:`;
-    }
-    /**
-     * Extract JSON from Claude response
-     */
-    extractJsonFromResponse(text) {
-        // Try to find JSON in code blocks
-        const jsonBlockMatch = text.match(/```json\s*\n([\s\S]*?)\n```/);
-        if (jsonBlockMatch) {
-            return JSON.parse(jsonBlockMatch[1]);
-        }
-        // Try to find JSON in the text
-        const jsonMatch = text.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            return JSON.parse(jsonMatch[0]);
-        }
-        throw new Error('Could not extract JSON from Claude response');
-    }
     /**
      * Extract repository organization and project name using SDK Git class
      */
     async extractRepoInfo() {
         try {
             const remoteUrl = this.git.exec('remote get-url origin');
-            // Parse git@github.com:organization/project.git or https://github.com/organization/project.git
             const match = remoteUrl.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
             if (match) {
                 return {

package/dist/utils/validation.d.ts

@@ -89,9 +89,18 @@ export declare function validateSafePath(filePath: string, baseDir?: string): st
  * @throws Error if too large
  */
 export declare function validateJsonSize(jsonString: string, maxSizeBytes?: number): boolean;
+/**
+ * Slugify a string for use in identifiers (plan IDs, paths, etc.)
+ * Converts to lowercase, replaces non-alphanumeric with hyphens, trims hyphens.
+ *
+ * @param input - String to slugify
+ * @returns Slugified string (max 50 chars)
+ */
+export declare function slugify(input: string): string;
 /**
  * Validates plan ID format
- * Plan IDs follow format: fractary-faber-{work-id}-{YYYYMMDD}-{HHMMSS}
+ * Plan IDs follow format: {org}-{project}-{work-id}-{YYYYMMDD}-{HHMMSS}
+ * Also accepts legacy format: fractary-faber-{work-id}-{YYYYMMDD}-{HHMMSS}
  *
  * @param planId - Plan ID to validate
  * @returns True if valid

package/dist/utils/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAY1E;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMrG;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAQ7E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAWtD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBzD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAYpD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBvD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAYlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAoC3E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,GAAE,MAAoB,GAAG,OAAO,CAYhG;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAUtD"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAY1E;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMrG;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAQ7E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAWtD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBzD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAYpD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBvD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAYlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAoC3E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,GAAE,MAAoB,GAAG,OAAO,CAYhG;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAYtD"}

package/dist/utils/validation.js

@@ -189,18 +189,35 @@ export function validateJsonSize(jsonString, maxSizeBytes = 1024 * 1024) {
     }
     return true;
 }
+/**
+ * Slugify a string for use in identifiers (plan IDs, paths, etc.)
+ * Converts to lowercase, replaces non-alphanumeric with hyphens, trims hyphens.
+ *
+ * @param input - String to slugify
+ * @returns Slugified string (max 50 chars)
+ */
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 50);
+}
 /**
  * Validates plan ID format
- * Plan IDs follow format: fractary-faber-{work-id}-{YYYYMMDD}-{HHMMSS}
+ * Plan IDs follow format: {org}-{project}-{work-id}-{YYYYMMDD}-{HHMMSS}
+ * Also accepts legacy format: fractary-faber-{work-id}-{YYYYMMDD}-{HHMMSS}
  *
  * @param planId - Plan ID to validate
  * @returns True if valid
  * @throws Error if invalid
  */
 export function validatePlanId(planId) {
-    const planIdPattern = /^fractary-faber-\d+-\d{8}-\d{6}$/;
+    // Accepts one or more slug segments followed by -{digits}-{8digits}-{6digits}
+    // Only [a-z0-9-] allowed, which inherently prevents path traversal
+    const planIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*-\d+-\d{8}-\d{6}$/;
     if (!planIdPattern.test(planId)) {
-        throw new Error(`Invalid plan ID format: "${planId}". Expected format: fractary-faber-{work-id}-{YYYYMMDD}-{HHMMSS}`);
+        throw new Error(`Invalid plan ID format: "${planId}". Expected format: {org}-{project}-{work-id}-{YYYYMMDD}-{HHMMSS}`);
     }
     return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fractary/faber-cli",
-  "version": "1.5.25",
+  "version": "1.5.27",
   "description": "FABER CLI - Command-line interface for FABER development toolkit",
   "main": "dist/index.js",
   "bin": {
@@ -37,7 +37,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@fractary/core": "^0.5.0",
+    "@fractary/core": "^0.7.20",
     "@fractary/faber": "^2.4.14",
     "ajv": "^8.12.0",
     "chalk": "^5.0.0",

package/schemas/plan.schema.json

@@ -2,9 +2,9 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://raw.githubusercontent.com/fractary/faber/main/plugins/faber/config/schemas/plan.schema.json",
   "title": "FABER Plan Schema",
-  "description": "JSON Schema for FABER workflow plans generated by CLI or Claude plugin",
+  "description": "JSON Schema for FABER workflow plans generated by CLI or faber-planner agent",
   "type": "object",
-  "required": ["plan_id", "created_by", "created_at", "workflow", "phases"],
+  "required": ["id", "created_by", "created", "workflow", "items"],
   "additionalProperties": true,
   "properties": {
     "$schema": {
@@ -12,15 +12,14 @@
       "format": "uri",
       "description": "JSON Schema reference for IDE validation"
     },
-    "plan_id": {
+    "id": {
       "type": "string",
-      "pattern": "^fractary-faber-[0-9]+-[0-9]{8}-[0-9]{6}$",
-      "description": "Unique plan identifier (format: fractary-faber-{work-id}-{YYYYMMDD}-{HHMMSS})",
-      "examples": ["fractary-faber-258-20260106-143022"]
+      "description": "Unique plan identifier (format: {org}-{project}-{work-id}-{YYYYMMDD}-{HHMMSS})",
+      "examples": ["corthosai-etl-corthion-ai-258-20260106-143022", "fractary-faber-258-20260106-143022"]
     },
     "created_by": {
       "type": "string",
-      "enum": ["cli", "claude", "api"],
+      "enum": ["cli", "faber-planner", "api"],
       "description": "Tool that created the plan"
     },
     "cli_version": {
@@ -29,202 +28,296 @@
       "description": "Version of CLI that created the plan (if created_by: cli)",
       "examples": ["3.4.0"]
     },
-    "created_at": {
+    "created": {
       "type": "string",
       "format": "date-time",
       "description": "ISO 8601 timestamp when plan was created"
     },
-    "issue": {
+    "metadata": {
       "type": "object",
-      "required": ["source", "id"],
-      "description": "Issue metadata - links plan to originating work item",
+      "description": "Structured metadata for analytics and partitioning",
       "properties": {
-        "source": {
+        "org": {
           "type": "string",
-          "enum": ["github", "jira", "linear", "manual"],
-          "description": "Issue tracking system"
+          "description": "GitHub organization"
         },
-        "id": {
+        "project": {
           "type": "string",
-          "description": "Issue identifier (e.g., issue number)"
+          "description": "Project/repository name"
         },
-        "url": {
+        "subproject": {
           "type": "string",
-          "format": "uri",
-          "description": "Full URL to issue"
-        }
+          "description": "Subproject identifier (e.g., issue-258, ipeds-admissions)"
+        },
+        "year": { "type": "string" },
+        "month": { "type": "string" },
+        "day": { "type": "string" },
+        "hour": { "type": "string" },
+        "minute": { "type": "string" },
+        "second": { "type": "string" }
       }
     },
-    "branch": {
-      "type": "string",
-      "description": "Git branch name for this workflow (e.g., feature/258)"
-    },
-    "worktree": {
-      "type": "string",
-      "description": "Git worktree path (e.g., ~/.claude-worktrees/fractary-myproject-258)"
+    "source": {
+      "type": "object",
+      "description": "How the plan was sourced",
+      "properties": {
+        "input": {
+          "type": "string",
+          "description": "Original user input"
+        },
+        "work_id": {
+          "type": ["string", "null"],
+          "description": "Work item ID (if work_id planning mode)"
+        },
+        "planning_mode": {
+          "type": "string",
+          "enum": ["work_id", "target"],
+          "description": "How the plan was initiated"
+        },
+        "target_match": {
+          "type": ["object", "null"],
+          "description": "Target pattern match info (if target planning mode)"
+        },
+        "expanded_from": {
+          "type": ["string", "null"],
+          "description": "Parent plan if this was expanded from a multi-target plan"
+        }
+      }
     },
     "workflow": {
-      "type": "string",
-      "description": "Workflow type identifier (e.g., etl, bugfix, core)"
+      "type": "object",
+      "required": ["id", "inheritance_chain", "phases"],
+      "description": "Full resolved workflow with all steps and prompts",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Workflow identifier (e.g., fractary-faber:default, dataset-create)"
+        },
+        "resolved_at": {
+          "type": "string",
+          "format": "date-time",
+          "description": "When the workflow was resolved"
+        },
+        "inheritance_chain": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Workflow inheritance chain from child to root ancestor"
+        },
+        "phases": {
+          "type": "object",
+          "description": "Resolved phases with merged steps from inheritance chain",
+          "properties": {
+            "frame": { "$ref": "#/definitions/resolved_phase" },
+            "architect": { "$ref": "#/definitions/resolved_phase" },
+            "build": { "$ref": "#/definitions/resolved_phase" },
+            "evaluate": { "$ref": "#/definitions/resolved_phase" },
+            "release": { "$ref": "#/definitions/resolved_phase" }
+          }
+        }
+      }
     },
-    "overall_complexity": {
+    "autonomy": {
       "type": "string",
-      "enum": ["low", "medium", "high"],
-      "description": "Overall estimated complexity"
+      "enum": ["supervised", "assisted", "autonomous", "guarded"],
+      "description": "Autonomy level for workflow execution"
     },
-    "estimated_phases": {
-      "type": "integer",
-      "minimum": 1,
-      "description": "Estimated number of phases to complete"
+    "phases_to_run": {
+      "type": ["array", "null"],
+      "items": { "type": "string" },
+      "description": "Phase filter (null = run all enabled phases)"
     },
-    "special_considerations": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "Special notes or warnings for this workflow"
+    "step_to_run": {
+      "type": ["string", "null"],
+      "description": "Step filter (null = run all steps)"
     },
-    "phases": {
+    "additional_instructions": {
+      "type": ["string", "null"],
+      "description": "Additional instructions for the executor"
+    },
+    "items": {
       "type": "array",
-      "description": "Ordered list of workflow phases",
+      "description": "Plan items (one per target/work-id)",
       "items": {
-        "$ref": "#/definitions/phase"
+        "$ref": "#/definitions/plan_item"
       }
     },
-    "metadata": {
+    "execution": {
       "type": "object",
-      "description": "Additional metadata (flexible)",
+      "description": "Execution metadata",
       "properties": {
-        "org": {
+        "mode": {
           "type": "string",
-          "description": "GitHub organization"
+          "enum": ["sequential", "parallel"],
+          "description": "Execution mode for multiple items"
         },
-        "project": {
-          "type": "string",
-          "description": "Project/repository name"
+        "max_concurrent": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Max concurrent executions (if parallel mode)"
         },
-        "subproject": {
+        "status": {
           "type": "string",
-          "description": "Subproject identifier (optional)"
+          "enum": ["pending", "in_progress", "completed", "failed"],
+          "description": "Execution status"
+        },
+        "started_at": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "completed_at": {
+          "type": ["string", "null"],
+          "format": "date-time"
+        },
+        "results": {
+          "type": "array",
+          "description": "Per-item execution results"
         }
       }
-    },
-    "autonomy": {
-      "type": "string",
-      "enum": ["supervised", "assisted", "autonomous", "guarded"],
-      "description": "Autonomy level for workflow execution"
     }
   },
   "definitions": {
-    "phase": {
+    "resolved_phase": {
       "type": "object",
-      "required": ["phase", "description", "steps"],
+      "description": "A resolved workflow phase with merged steps",
       "properties": {
-        "phase": {
-          "type": "string",
-          "description": "Phase identifier (e.g., frame, architect, build, evaluate, release)"
+        "enabled": {
+          "type": "boolean",
+          "description": "Whether this phase is enabled"
         },
         "description": {
           "type": "string",
-          "description": "What this phase accomplishes"
+          "description": "Phase description"
         },
         "steps": {
           "type": "array",
-          "description": "Specific steps for this phase",
+          "description": "Resolved steps for this phase",
           "items": {
-            "$ref": "#/definitions/step"
+            "$ref": "#/definitions/workflow_step"
           }
         },
-        "success_criteria": {
+        "pre_steps": {
           "type": "array",
-          "description": "Criteria to verify phase completion",
-          "items": {
-            "type": "string"
-          }
+          "items": { "$ref": "#/definitions/workflow_step" }
         },
-        "complexity": {
-          "type": "string",
-          "enum": ["low", "medium", "high"],
-          "description": "Phase complexity estimate"
+        "post_steps": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/workflow_step" }
+        },
+        "require_approval": {
+          "type": "boolean"
+        },
+        "max_retries": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "result_handling": {
+          "$ref": "#/definitions/result_handling"
         }
       }
     },
-    "step": {
+    "workflow_step": {
       "type": "object",
-      "required": ["action"],
+      "required": ["id", "prompt"],
+      "description": "A resolved workflow step with executable prompt",
       "properties": {
-        "action": {
+        "id": {
           "type": "string",
-          "description": "Specific action to take"
+          "description": "Step identifier (e.g., build-engineer, evaluate-deploy-apply-test)"
         },
-        "details": {
+        "name": {
           "type": "string",
-          "description": "Additional context or requirements"
+          "description": "Human-readable step name"
         },
-        "command": {
-          "type": ["string", "null"],
-          "description": "Shell command to execute (optional)"
+        "description": {
+          "type": "string",
+          "description": "Step description"
         },
         "prompt": {
           "type": "string",
-          "description": "LLM prompt for this step (optional)"
+          "description": "Executable slash command for this step (e.g., /fractary-faber-code:engineer --work-id {work_id})"
+        },
+        "source": {
+          "type": "string",
+          "description": "Source workflow that defines this step (set during merge resolution)"
         },
-        "artifacts": {
+        "guards": {
           "type": "object",
-          "description": "Expected artifacts from this step"
+          "description": "Guard conditions for step execution",
+          "properties": {
+            "skip_if": { "type": "string" },
+            "require_if": { "type": "string" }
+          }
+        },
+        "result_handling": {
+          "$ref": "#/definitions/result_handling"
+        },
+        "position": {
+          "type": "string",
+          "enum": ["pre_step", "step", "post_step"],
+          "description": "Position type within the phase"
         }
       }
-    }
-  },
-  "examples": [
-    {
-      "plan_id": "fractary-faber-258-20260106-143022",
-      "created_by": "cli",
-      "cli_version": "3.4.0",
-      "created_at": "2026-01-06T14:30:22Z",
-      "issue": {
-        "source": "github",
-        "id": "258",
-        "url": "https://github.com/fractary/myproject/issues/258"
-      },
-      "branch": "feature/258",
-      "worktree": "~/.claude-worktrees/fractary-myproject-258",
-      "workflow": "etl",
-      "overall_complexity": "medium",
-      "estimated_phases": 5,
-      "phases": [
-        {
-          "phase": "frame",
-          "description": "Understand requirements and plan approach",
-          "steps": [
-            {
-              "action": "Read issue description and extract requirements",
-              "details": "Identify data source, target format, and validation rules"
-            }
-          ],
-          "success_criteria": [
-            "Requirements documented",
-            "Data source identified"
-          ],
-          "complexity": "low"
-        },
-        {
-          "phase": "architect",
-          "description": "Design ETL pipeline architecture",
-          "steps": [
-            {
-              "action": "Design data transformation logic",
-              "details": "Map source fields to target schema"
+    },
+    "result_handling": {
+      "type": "object",
+      "description": "Result handling configuration",
+      "properties": {
+        "on_success": { "type": "string" },
+        "on_warning": { "type": "string" },
+        "on_failure": { "type": "string" },
+        "on_pending_input": { "type": "string" }
+      }
+    },
+    "plan_item": {
+      "type": "object",
+      "description": "A single plan item (one per target or work-id)",
+      "properties": {
+        "target": {
+          "type": "string",
+          "description": "Target identifier"
+        },
+        "work_id": {
+          "type": ["string", "null"],
+          "description": "Work item ID (null if target mode)"
+        },
+        "planning_mode": {
+          "type": "string",
+          "enum": ["work_id", "target"]
+        },
+        "issue": {
+          "type": ["object", "null"],
+          "description": "Issue metadata (null if target mode)",
+          "properties": {
+            "number": { "type": "integer" },
+            "title": { "type": "string" },
+            "url": { "type": "string", "format": "uri" }
+          }
+        },
+        "target_context": {
+          "type": ["object", "null"],
+          "description": "Target-specific context (null if work_id mode)"
+        },
+        "branch": {
+          "type": "object",
+          "properties": {
+            "name": { "type": "string" },
+            "status": {
+              "type": "string",
+              "enum": ["new", "ready", "resume"]
+            },
+            "resume_from": {
+              "type": "object",
+              "properties": {
+                "phase": { "type": "string" },
+                "step": { "type": "string" }
+              }
             }
-          ],
-          "success_criteria": [
-            "Architecture documented",
-            "Data flow mapped"
-          ],
-          "complexity": "medium"
+          }
+        },
+        "worktree": {
+          "type": ["string", "null"]
         }
-      ],
-      "autonomy": "supervised"
+      }
     }
-  ]
+  }
 }