@williambeto/ai-workflow 1.19.1 → 2.2.0

package/src/core/gates/branch-gate.js

@@ -0,0 +1,146 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+function slugify(value = "task") {
+  return String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48) || "task";
+}
+
+/**
+ * BranchGate - Protects main/master and can recover safely onto a scoped branch.
+ */
+export class BranchGate {
+  constructor({ protectedBranches = ["main", "master"], memoryDir, cwd = process.cwd() } = {}) {
+    this.protectedBranches = protectedBranches;
+    this.logPath = memoryDir ? path.join(memoryDir, "GATE_ALERTS.log") : null;
+    this.cwd = cwd;
+  }
+
+  run(command) {
+    return execSync(command, {
+      cwd: this.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  }
+
+  log(event) {
+    if (!this.logPath) return;
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${event}\n`;
+    try {
+      if (!fs.existsSync(path.dirname(this.logPath))) fs.mkdirSync(path.dirname(this.logPath), { recursive: true });
+      fs.appendFileSync(this.logPath, logEntry);
+    } catch (error) {
+      console.error(`Failed to write to gate log: ${error.message}`);
+    }
+  }
+
+  getDirtyState() {
+    const lines = this.run("git status --short").split("\n").filter(Boolean);
+    const tracked = lines.filter((line) => !line.startsWith("??"));
+    const untracked = lines.filter((line) => line.startsWith("??"));
+    return { clean: lines.length === 0, tracked, untracked, lines };
+  }
+
+  createScopedBranch(taskSlug) {
+    const base = `feat/${slugify(taskSlug)}`;
+    let candidate = base;
+    let suffix = 2;
+    while (true) {
+      try {
+        this.run(`git show-ref --verify --quiet refs/heads/${candidate}`);
+        candidate = `${base}-${suffix++}`;
+      } catch {
+        break;
+      }
+    }
+    this.run(`git switch -c ${candidate}`);
+    return candidate;
+  }
+
+  getCurrentBranch() {
+    try {
+      return this.run("git branch --show-current") || this.run("git symbolic-ref --short HEAD") || "unknown";
+    } catch {
+      try {
+        return this.run("git symbolic-ref --short HEAD") || "unknown";
+      } catch {
+        return "unknown";
+      }
+    }
+  }
+
+  /**
+   * @param {string} override
+   * @param {{autoRecover?: boolean, taskSlug?: string, readOnly?: boolean}} options
+   */
+  check(override = "", { autoRecover = false, taskSlug = "implementation", readOnly = false } = {}) {
+    if (readOnly) {
+      const currentBranch = this.getCurrentBranch();
+      return { blocked: false, branch: currentBranch, recovered: false, readOnly: true };
+    }
+
+    try {
+      // Enforce fail-closed: verify inside worktree first
+      try {
+        this.run("git rev-parse --is-inside-work-tree");
+      } catch (e) {
+        const reason = "Not inside a Git repository or Git is unavailable. Implementation work is blocked.";
+        this.log(`BLOCKED: ${reason}`);
+        return { blocked: true, branch: "unknown", reason };
+      }
+
+      const currentBranch = this.getCurrentBranch();
+      if (currentBranch === "unknown") {
+        const reason = "Could not determine current Git branch name. Implementation work is blocked.";
+        this.log(`BLOCKED: ${reason}`);
+        return { blocked: true, branch: "unknown", reason };
+      }
+      const isProtected = this.protectedBranches.includes(currentBranch);
+      if (!isProtected) return { blocked: false, branch: currentBranch, recovered: false };
+
+      if (override && override.trim().length >= 20) {
+        this.log(`AUTHORIZED BYPASS on '${currentBranch}': ${override.trim()}`);
+        return { blocked: false, branch: currentBranch, authorized: true, recovered: false };
+      }
+
+      if (autoRecover) {
+        const dirty = this.getDirtyState();
+        if (dirty.tracked.length > 0) {
+          const reason = `Unsafe tracked changes prevent Branch Gate Auto-Recovery: ${dirty.tracked.join(", ")}`;
+          this.log(`BLOCKED AUTO-RECOVERY on '${currentBranch}': ${reason}`);
+          return { blocked: true, branch: currentBranch, reason, dirtyState: dirty };
+        }
+
+        const recoveredBranch = this.createScopedBranch(taskSlug);
+        this.log(`AUTO-RECOVERED '${currentBranch}' -> '${recoveredBranch}'`);
+        return {
+          blocked: false,
+          branch: recoveredBranch,
+          branchBefore: currentBranch,
+          recovered: true,
+          dirtyState: dirty
+        };
+      }
+
+      const reason = override && override.trim().length < 20
+        ? "Override justification too short (min 20 chars)."
+        : `Direct commits to '${currentBranch}' are prohibited.`;
+      this.log(`BLOCKED ATTEMPT on '${currentBranch}': ${reason}`);
+      return {
+        blocked: true,
+        branch: currentBranch,
+        reason: `${reason} Enable safe auto-recovery or use AI_OVERRIDE with a concrete justification.`
+      };
+    } catch (error) {
+      const reason = `Git command failure on branch gate check: ${error.message}`;
+      this.log(`BLOCKED: ${reason}`);
+      return { blocked: true, branch: "unknown", error: error.message, reason, recovered: false };
+    }
+  }
+}

package/src/core/handoff/handoff-engine.js

@@ -0,0 +1,104 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * HandoffEngine - Bundles project context into a single Markdown packet.
+ */
+export class HandoffEngine {
+  constructor({ cwd }) {
+    this.cwd = cwd;
+  }
+
+   /**
+   * Generates a handoff packet.
+   * @param {Object} data - Context data.
+   * @returns {Promise<string>} The generated packet content.
+   */
+  async generate({ taskId, author, status, specPaths = [], nextActions, evidence = null }) {
+    const timestamp = new Date().toISOString();
+    
+    // 1. Collect Specs content
+    let specsContent = "";
+    for (const specPath of specPaths) {
+      const absolutePath = path.isAbsolute(specPath) ? specPath : path.join(this.cwd, specPath);
+      try {
+        const content = await fs.readFile(absolutePath, "utf8");
+        specsContent += `### File: ${specPath}\n\n${content}\n\n`;
+      } catch (err) {
+        specsContent += `### File: ${specPath}\n\n[Error reading file: ${err.message}]\n\n`;
+      }
+    }
+
+    // 2. Capture Git Diff
+    let gitDiff = "No changes detected.";
+    try {
+      gitDiff = execSync("git diff HEAD", { cwd: this.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || "No changes detected.";
+    } catch (err) {
+      gitDiff = `[Error capturing diff: ${err.message}]`;
+    }
+
+    // 3. Read EVIDENCE.json or use provided in-memory evidence
+    let evidenceJson = "{}";
+    let evidenceSummary = "No evidence found.";
+    if (evidence) {
+      const data = typeof evidence === "string" ? JSON.parse(evidence) : evidence;
+      evidenceJson = JSON.stringify(data, null, 2);
+      evidenceSummary = `Status: ${data.status || data.internalStatus || "unknown"}, Commands: ${data.commands?.length || 0}`;
+    } else {
+      const evidencePath = path.join(this.cwd, "EVIDENCE.json");
+      try {
+        const content = await fs.readFile(evidencePath, "utf8");
+        const data = JSON.parse(content);
+        evidenceJson = JSON.stringify(data, null, 2);
+        evidenceSummary = `Status: ${data.status}, Commands: ${data.commands?.length || 0}`;
+      } catch (err) {
+        // Optional: don't fail if evidence is missing
+      }
+    }
+
+    // 4. Populate Template
+    const possibleTemplatePaths = [
+      path.join(this.cwd, ".ai-workflow/templates/HANDOFF.template.md"),
+      path.join(this.cwd, ".ai-workflow/harness/handoffs/HANDOFF.template.md"),
+      path.join(import.meta.dirname, "../../../dist-assets/templates/HANDOFF.template.md"),
+      path.join(import.meta.dirname, "../../../assets/templates/HANDOFF.template.md")
+    ];
+
+    let template = null;
+    let lastError = null;
+
+    for (const tPath of possibleTemplatePaths) {
+      try {
+        template = await fs.readFile(tPath, "utf8");
+        break;
+      } catch (err) {
+        lastError = err;
+      }
+    }
+
+    if (!template) {
+      throw new Error(`CRITICAL FAILURE: Could not locate HANDOFF.template.md. Tried paths:\n${possibleTemplatePaths.join("\n")}\nLast error: ${lastError?.message}`);
+    }
+
+    const packet = template
+      .replace("${TASK_ID}", taskId || "unknown")
+      .replace("${TIMESTAMP}", timestamp)
+      .replace("${AUTHOR}", author || "AI Workflow Kit")
+      .replace("${STATUS}", status || "IN_PROGRESS")
+      .replace("${SPECS_CONTENT}", specsContent || "No specs provided.")
+      .replace("${EVIDENCE_SUMMARY}", evidenceSummary)
+      .replace("${EVIDENCE_JSON}", evidenceJson)
+      .replace("${GIT_DIFF}", gitDiff)
+      .replace("${NEXT_ACTIONS}", nextActions || "Awaiting manager assignment.");
+
+    const handoffDir = path.join(this.cwd, ".ai-workflow/handoffs");
+    await fs.mkdir(handoffDir, { recursive: true });
+    
+    const packetName = `HANDOFF-${taskId || "TMP"}-${Date.now()}.md`;
+    const packetPath = path.join(handoffDir, packetName);
+    await fs.writeFile(packetPath, packet);
+
+    return packetPath;
+  }
+}

package/src/core/healing/cli-remediation-executor.js

@@ -0,0 +1,151 @@
+import { spawnSync, execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Determines which npm scripts are available in the consumer project.
+ * @param {string} cwd
+ * @returns {Promise<Record<string, string>>}
+ */
+async function readScripts(cwd) {
+  try {
+    const pkg = JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf8"));
+    return pkg.scripts || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Returns the list of files changed since the last commit.
+ * Used to detect whether remediation produced any observable change.
+ * @param {string} cwd
+ * @returns {string[]}
+ */
+function getChangedFiles(cwd) {
+  try {
+    const output = execSync("git status --short", { cwd, encoding: "utf8" });
+    return output
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => line.slice(3).trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Maps an affectedCheck source string to likely npm script names to re-run.
+ * e.g. "check:branchSafety" → [] (no command can fix a branch issue)
+ *      "evidence" with failed test → ["test"]
+ * @param {string[]} affectedChecks
+ * @param {Record<string, string>} scripts
+ * @returns {string[]} ordered list of script names to retry
+ */
+function resolveRetryScripts(affectedChecks, scripts) {
+  const retry = new Set();
+
+  for (const check of affectedChecks) {
+    // Evidence failures → re-run the failing validation scripts
+    if (check === "evidence" || check === "result") {
+      if (scripts.test) retry.add("test");
+      if (scripts.lint) retry.add("lint");
+      if (scripts.build) retry.add("build");
+      if (scripts.typecheck) retry.add("typecheck");
+    }
+    // Specific check types
+    if (check.includes("test")) retry.add("test");
+    if (check.includes("lint")) retry.add("lint");
+    if (check.includes("build")) retry.add("build");
+    if (check.includes("typecheck")) retry.add("typecheck");
+  }
+
+  // Filter to only scripts that actually exist
+  return [...retry].filter((name) => !!scripts[name]);
+}
+
+/**
+ * CLI Remediation Executor — default implementation for `ai-workflow run`.
+ *
+ * Plugs into HealerEngine as the `remediate` function. On each attempt it:
+ *   1. Reads the remediation-request.json to understand what failed
+ *   2. Re-runs the affected npm scripts (lint, test, build, typecheck)
+ *   3. Reports changed files and whether any script now passes
+ *
+ * Design constraints:
+ *   - This executor does NOT modify source code — it only re-runs validation commands.
+ *   - It is effective for transient failures (e.g. flaky tests, stale build artifacts).
+ *   - For structural failures (missing tests, broken implementation), it will exhaust
+ *     its attempt budget and return applied:false, triggering a BLOCKED status.
+ *   - The user is shown clear output on each attempt.
+ *
+ * @param {Object} ctx - Context provided by HealerEngine.run()
+ * @param {number} ctx.attempt
+ * @param {number} ctx.maxAttempts
+ * @param {string} ctx.mode
+ * @param {string} ctx.taskSlug
+ * @param {Object} ctx.result - Current combined validation result
+ * @param {string[]} ctx.affectedChecks
+ * @param {string}  ctx.requestPath - Path to remediation-request.json
+ * @param {string}  cwd - Consumer project working directory (bound via closure)
+ * @returns {Promise<{applied: boolean, changedFiles?: string[], evidenceAdded?: string[], reason?: string}>}
+ */
+export function createCliRemediationExecutor(cwd) {
+  return async function remediationExecutor({ attempt, maxAttempts, mode, affectedChecks, requestPath }) {
+    console.log(`\n[HEALER] Attempt ${attempt}/${maxAttempts} — mode: ${mode}`);
+    console.log(`[HEALER] Affected: ${affectedChecks.join(", ")}`);
+
+    const scripts = await readScripts(cwd);
+    const filesBefore = getChangedFiles(cwd);
+    const toRetry = resolveRetryScripts(affectedChecks, scripts);
+
+    if (toRetry.length === 0) {
+      console.log("[HEALER] No retryable scripts found for the affected checks.");
+      console.log(`[HEALER] Review ${requestPath} for details.`);
+      return {
+        applied: false,
+        reason: `No npm scripts available to address: ${affectedChecks.join(", ")}. Manual remediation required.`
+      };
+    }
+
+    console.log(`[HEALER] Re-running: ${toRetry.map((s) => `npm run ${s}`).join(", ")}`);
+
+    const results = [];
+    let anyPassed = false;
+
+    for (const scriptName of toRetry) {
+      process.stdout.write(`  → npm run ${scriptName} ... `);
+      const result = spawnSync("npm", ["run", scriptName], {
+        cwd,
+        shell: true,
+        encoding: "utf8",
+        timeout: 120000
+      });
+      const passed = result.status === 0;
+      if (passed) anyPassed = true;
+      console.log(passed ? "PASS" : "FAIL");
+      results.push({ script: scriptName, passed, exitCode: result.status });
+    }
+
+    const filesAfter = getChangedFiles(cwd);
+    const changedFiles = filesAfter.filter((f) => !filesBefore.includes(f));
+
+    if (!anyPassed && changedFiles.length === 0) {
+      console.log("[HEALER] No scripts passed and no files changed — remediation had no effect.");
+      return {
+        applied: false,
+        reason: `Re-ran ${toRetry.join(", ")} — all failed. Structural fix required by the implementing agent.`
+      };
+    }
+
+    console.log(`[HEALER] Applied: ${results.filter((r) => r.passed).map((r) => r.script).join(", ") || "none passed"}`);
+    if (changedFiles.length) console.log(`[HEALER] Changed files: ${changedFiles.join(", ")}`);
+
+    return {
+      applied: true,
+      changedFiles,
+      evidenceAdded: anyPassed ? ["validation-output"] : []
+    };
+  };
+}

package/src/core/healing/healer-engine.js

@@ -0,0 +1,179 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { isRecoverableGateFailure } from "../statuses.js";
+
+const MODE_ATTEMPTS = Object.freeze({ quick: 1, standard: 2, full: 3 });
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function collectBlockingFindings(result = {}) {
+  const findings = [];
+  const add = (source, value) => {
+    if (!value || typeof value !== "object") return;
+    const status = value.status || value.overallStatus;
+    if (!["FAIL", "FAIL_QUALITY_GATE", "FAIL_DELEGATION_GATE", "BLOCKED"].includes(status)) return;
+    findings.push({
+      source,
+      status,
+      missing: Array.isArray(value.missing) ? [...value.missing].sort() : [],
+      reason: value.reason || value.summary || ""
+    });
+  };
+
+  add("result", result);
+  add("evidence", result.evidence);
+  add("quality", result.quality);
+  const checks = result.quality?.checks || result.policyValidation?.checks || result.checks || {};
+  for (const [name, check] of Object.entries(checks)) add(`check:${name}`, check);
+  return findings.sort((a, b) => a.source.localeCompare(b.source));
+}
+
+export class HealerEngine {
+  constructor({ cwd, mode = "standard", taskSlug = "implementation", maxAttempts = null } = {}) {
+    this.cwd = cwd;
+    this.mode = MODE_ATTEMPTS[mode] ? mode : "standard";
+    this.taskSlug = taskSlug;
+    this.maxAttempts = maxAttempts ?? MODE_ATTEMPTS[this.mode];
+  }
+
+  get statePath() {
+    return path.join(this.cwd, ".ai-workflow", `healing-state-${this.taskSlug}.json`);
+  }
+
+  fingerprint(result) {
+    return crypto.createHash("sha256").update(stableJson(collectBlockingFindings(result))).digest("hex");
+  }
+
+  blockingCount(result) {
+    return collectBlockingFindings(result).length;
+  }
+
+  affectedChecks(result) {
+    return collectBlockingFindings(result).map((finding) => finding.source);
+  }
+
+  hasProgress(before, after, remediation = {}) {
+    if (!isRecoverableGateFailure(after.overallStatus)) return true;
+    const beforeCount = this.blockingCount(before);
+    const afterCount = this.blockingCount(after);
+    if (afterCount < beforeCount) return true;
+    if (this.fingerprint(before) !== this.fingerprint(after) && (remediation.changedFiles?.length || remediation.evidenceAdded?.length)) return true;
+    return false;
+  }
+
+  async writeState(state) {
+    await fs.mkdir(path.dirname(this.statePath), { recursive: true });
+    await fs.writeFile(this.statePath, JSON.stringify(state, null, 2));
+  }
+
+  async resetState() {
+    try { await fs.unlink(this.statePath); } catch {}
+  }
+
+  async writeRemediationRequest({ attempt, result }) {
+    const requestPath = path.join(this.cwd, ".ai-workflow", "remediation-request.json");
+    await fs.mkdir(path.dirname(requestPath), { recursive: true });
+    const request = {
+      taskSlug: this.taskSlug,
+      executionMode: this.mode,
+      attempt,
+      maxAttempts: this.maxAttempts,
+      status: result.overallStatus,
+      affectedChecks: this.affectedChecks(result),
+      findingsFingerprint: this.fingerprint(result),
+      instruction: "Apply the smallest safe correction for the listed gates, then rerun validation. Do not broaden scope."
+    };
+    await fs.writeFile(requestPath, JSON.stringify(request, null, 2));
+    return requestPath;
+  }
+
+  async run({ initialResult, validate, remediate }) {
+    let current = initialResult;
+    const history = [];
+    const seen = new Set();
+
+    if (!isRecoverableGateFailure(current.overallStatus)) {
+      await this.resetState();
+      return { ...current, remediation: { status: "NOT_REQUIRED", attempts: 0, history } };
+    }
+
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+      const fingerprint = this.fingerprint(current);
+      if (seen.has(fingerprint)) {
+        const blocked = { overallStatus: "BLOCKED", reason: "Repeated unresolved finding", previousResult: current };
+        await this.writeState({ status: "BLOCKED", reason: blocked.reason, attempts: attempt - 1, history });
+        return { ...blocked, remediation: { status: "BLOCKED", attempts: attempt - 1, history } };
+      }
+      seen.add(fingerprint);
+
+      const requestPath = await this.writeRemediationRequest({ attempt, result: current });
+      if (typeof remediate !== "function") {
+        const blocked = { overallStatus: "BLOCKED", reason: "No remediation executor available", previousResult: current, requestPath };
+        await this.writeState({ status: "BLOCKED", reason: blocked.reason, attempts: attempt - 1, history, requestPath });
+        return { ...blocked, remediation: { status: "BLOCKED", attempts: attempt - 1, history, requestPath } };
+      }
+
+      const remediation = await remediate({
+        attempt,
+        maxAttempts: this.maxAttempts,
+        mode: this.mode,
+        taskSlug: this.taskSlug,
+        result: current,
+        affectedChecks: this.affectedChecks(current),
+        requestPath
+      });
+
+      if (!remediation?.applied) {
+        const blocked = { overallStatus: "BLOCKED", reason: remediation?.reason || "Remediation was not applied", previousResult: current, requestPath };
+        history.push({ attempt, before: current.overallStatus, remediation, after: "NOT_RUN", progress: false });
+        await this.writeState({ status: "BLOCKED", reason: blocked.reason, attempts: attempt, history });
+        return { ...blocked, remediation: { status: "BLOCKED", attempts: attempt, history } };
+      }
+
+      const next = await validate({ affectedChecks: this.affectedChecks(current), attempt });
+      const progress = this.hasProgress(current, next, remediation);
+      history.push({
+        attempt,
+        before: current.overallStatus,
+        after: next.overallStatus,
+        progress,
+        changedFiles: remediation.changedFiles || [],
+        evidenceAdded: remediation.evidenceAdded || [],
+        affectedChecks: this.affectedChecks(current)
+      });
+      await this.writeState({ status: next.overallStatus, attempts: attempt, history });
+
+      if (!isRecoverableGateFailure(next.overallStatus)) {
+        await this.resetState();
+        return { ...next, remediation: { status: "RESOLVED", attempts: attempt, history } };
+      }
+
+      if (!progress) {
+        return {
+          overallStatus: "BLOCKED",
+          reason: "Remediation made no measurable progress",
+          previousResult: next,
+          remediation: { status: "BLOCKED", attempts: attempt, history }
+        };
+      }
+
+      current = next;
+    }
+
+    return {
+      overallStatus: "BLOCKED",
+      reason: `Quality remediation attempts exhausted for ${this.mode} mode`,
+      previousResult: current,
+      remediation: { status: "BLOCKED", attempts: this.maxAttempts, history }
+    };
+  }
+}
+
+export { MODE_ATTEMPTS, collectBlockingFindings };

package/src/core/identity.js

@@ -0,0 +1,43 @@
+export const AGENT_MAP = {
+  "atlas": "Atlas",
+  "nexus": "Nexus",
+  "orion": "Orion",
+  "astra": "Astra",
+  "sage": "Sage",
+  "phoenix": "Phoenix",
+  "architecture": "Architecture-Specialist",
+  "backend-development": "Backend-Engineer",
+  "deployment": "Deployment-Specialist",
+  "design-principles": "Design-Specialist",
+  "documentation": "Docs-Engineer",
+  "frontend-development": "Frontend-Engineer",
+  "full-stack-development": "Full-Stack-Engineer",
+  "optimize-tokens": "Token-Economist",
+  "pr-workflow": "PR-Manager",
+  "product-discovery": "Discovery-Analyst",
+  "product-planning": "Product-Planner",
+  "project-memory": "Memory-Guardian",
+  "prompt-engineer": "Prompt-Engineer",
+  "qa-workflow": "QA-Engineer",
+  "refactoring": "Refactoring-Specialist",
+  "release-workflow": "Release-Specialist",
+  "spec-driven-development": "SDD-Specialist",
+  "technical-leadership": "Technical-Leader",
+  "ui-ux-design": "UI-UX-Engineer"
+};
+
+/**
+ * Returns the canonical (commercial) name for an agent given its internal slug.
+ * Falls back to PascalCase translation if no mapping exists.
+ * @param {string} slug
+ * @returns {string}
+ */
+export function getCanonicalAgentName(slug) {
+  if (AGENT_MAP[slug]) return AGENT_MAP[slug];
+  
+  // Fallback: convert slug-case to PascalCase
+  return slug
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+}

package/{packages/ai-workflow/src → src}/core/install-plan.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { getTemplateFiles } from "./templates.js";
 
-export async function createInstallPlan({ cwd, exists, profile }) {
+export async function createInstallPlan({ cwd, exists, profile = "standard" }) {
   const actions = [];
   const templateFiles = getTemplateFiles(profile);
   const installRoot = ".ai-workflow";
@@ -22,10 +22,10 @@ export async function createInstallPlan({ cwd, exists, profile }) {
     });
   }
 
-  const configPath = path.join(cwd, ".ai-workflow.json");
+  const configPath = path.join(cwd, ".ai-workflow/config.json");
   actions.push({
     type: (await exists(configPath)) ? "conflict" : "create",
-    relativePath: ".ai-workflow.json",
+    relativePath: ".ai-workflow/config.json",
     absolutePath: configPath,
     content: null
   });