@sureshdsk/devflow-mcp 3.0.0 → 3.0.1

package/scripts/init-schema.js

@@ -1,16 +1,16 @@
-const fs = require("fs");
-const path = require("path");
-const yaml = require("js-yaml");
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
 
 function getProjectConfigPath(projectRoot) {
-  return path.join(projectRoot, ".devflow", "project-config.json");
+  return path.join(projectRoot, 'devflow', 'project-config.json');
 }
 
 function readProjectConfig(projectRoot) {
   const configPath = getProjectConfigPath(projectRoot);
   if (!fs.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
   } catch {
     return {};
   }
@@ -19,7 +19,7 @@ function readProjectConfig(projectRoot) {
 function writeProjectConfig(projectRoot, config) {
   const configPath = getProjectConfigPath(projectRoot);
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
 }
 
 function readSchemasFromDir(baseDir, source) {
@@ -31,9 +31,9 @@ function readSchemasFromDir(baseDir, source) {
 
   const schemas = [];
   for (const entryName of entries) {
-    const schemaPath = path.join(baseDir, entryName, "schema.yaml");
+    const schemaPath = path.join(baseDir, entryName, 'schema.yaml');
     if (!fs.existsSync(schemaPath)) continue;
-    const parsed = yaml.load(fs.readFileSync(schemaPath, "utf-8")) || {};
+    const parsed = yaml.load(fs.readFileSync(schemaPath, 'utf-8')) || {};
     if (!parsed.name) {
       throw new Error(`Invalid schema at ${schemaPath}: missing name`);
     }
@@ -41,7 +41,7 @@ function readSchemasFromDir(baseDir, source) {
       id: String(parsed.name),
       source,
       schemaPath,
-      templatesDir: path.join(path.dirname(schemaPath), "templates"),
+      templatesDir: path.join(path.dirname(schemaPath), 'templates'),
     });
   }
   return schemas;
@@ -50,11 +50,11 @@ function readSchemasFromDir(baseDir, source) {
 function discoverSchemaTemplates(options) {
   const projectRoot = options.projectRoot;
   const packageRoot = options.packageRoot;
-  const bundledDir = options.bundledDir || path.join(packageRoot, "src", "schemas");
-  const projectSchemaDir = path.join(projectRoot, "schemas");
+  const bundledDir = options.bundledDir || path.join(packageRoot, 'src', 'schemas');
+  const projectSchemaDir = path.join(projectRoot, 'schemas');
 
-  const bundled = readSchemasFromDir(bundledDir, "bundled");
-  const project = readSchemasFromDir(projectSchemaDir, "project");
+  const bundled = readSchemasFromDir(bundledDir, 'bundled');
+  const project = readSchemasFromDir(projectSchemaDir, 'project');
   const merged = [...bundled, ...project];
 
   const idToSchema = new Map();
@@ -62,7 +62,7 @@ function discoverSchemaTemplates(options) {
     const existing = idToSchema.get(schema.id);
     if (existing) {
       throw new Error(
-        `Schema ID conflict for "${schema.id}" between ${existing.source}:${existing.schemaPath} and ${schema.source}:${schema.schemaPath}`
+        `Schema ID conflict for "${schema.id}" between ${existing.source}:${existing.schemaPath} and ${schema.source}:${schema.schemaPath}`,
       );
     }
     idToSchema.set(schema.id, schema);
@@ -74,7 +74,7 @@ function discoverSchemaTemplates(options) {
 function assertKnownSchema(schemaId, availableSchemaIds) {
   if (!availableSchemaIds.includes(schemaId)) {
     throw new Error(
-      `Unknown schema "${schemaId}". Available schemas: ${availableSchemaIds.join(", ")}`
+      `Unknown schema "${schemaId}". Available schemas: ${availableSchemaIds.join(', ')}`,
     );
   }
 }
@@ -91,31 +91,31 @@ async function resolveInitSchemaSelection(options) {
 
   if (requestedSchema) {
     assertKnownSchema(requestedSchema, availableSchemaIds);
-    return { schemaId: requestedSchema, reason: "explicit" };
+    return { schemaId: requestedSchema, reason: 'explicit' };
   }
 
   if (!interactive) {
     if (existingDefaultSchema && availableSchemaIds.includes(existingDefaultSchema)) {
-      return { schemaId: existingDefaultSchema, reason: "existing-default" };
+      return { schemaId: existingDefaultSchema, reason: 'existing-default' };
     }
-    if (availableSchemaIds.includes("spec-driven")) {
-      return { schemaId: "spec-driven", reason: "non-interactive-fallback" };
+    if (availableSchemaIds.includes('spec-driven')) {
+      return { schemaId: 'spec-driven', reason: 'non-interactive-fallback' };
     }
     throw new Error(
-      `Non-interactive init requires a schema. Available schemas: ${availableSchemaIds.join(", ")}`
+      `Non-interactive init requires a schema. Available schemas: ${availableSchemaIds.join(', ')}`,
     );
   }
 
   if (existingDefaultSchema && availableSchemaIds.includes(existingDefaultSchema)) {
     const keep = (await confirmKeepExisting(existingDefaultSchema)) !== false;
     if (keep) {
-      return { schemaId: existingDefaultSchema, reason: "existing-default-kept" };
+      return { schemaId: existingDefaultSchema, reason: 'existing-default-kept' };
     }
   }
 
   const selected = await promptSelectSchema(availableSchemaIds, existingDefaultSchema);
   assertKnownSchema(selected, availableSchemaIds);
-  return { schemaId: selected, reason: "interactive-selection" };
+  return { schemaId: selected, reason: 'interactive-selection' };
 }
 
 module.exports = {

package/scripts/init-schema.test.js

@@ -1,18 +1,18 @@
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 const {
   discoverSchemaTemplates,
   resolveInitSchemaSelection,
   readProjectConfig,
   writeProjectConfig,
-} = require("./init-schema");
+} = require('./init-schema');
 
 function withTempDir(fn) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "devflow-init-schema-"));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devflow-init-schema-'));
   try {
     return fn(dir);
   } finally {
@@ -22,82 +22,82 @@ function withTempDir(fn) {
 
 function writeSchema(baseDir, id) {
   const schemaDir = path.join(baseDir, id);
-  fs.mkdirSync(path.join(schemaDir, "templates"), { recursive: true });
+  fs.mkdirSync(path.join(schemaDir, 'templates'), { recursive: true });
   fs.writeFileSync(
-    path.join(schemaDir, "schema.yaml"),
+    path.join(schemaDir, 'schema.yaml'),
     `name: ${id}\nversion: 1\nartifacts: []\n`,
-    "utf-8"
+    'utf-8',
   );
 }
 
-test("resolveInitSchemaSelection respects explicit schema", async () => {
+test('resolveInitSchemaSelection respects explicit schema', async () => {
   const result = await resolveInitSchemaSelection({
-    requestedSchema: "backend-api",
-    existingDefaultSchema: "spec-driven",
-    availableSchemaIds: ["spec-driven", "backend-api"],
+    requestedSchema: 'backend-api',
+    existingDefaultSchema: 'spec-driven',
+    availableSchemaIds: ['spec-driven', 'backend-api'],
     interactive: false,
   });
-  assert.equal(result.schemaId, "backend-api");
-  assert.equal(result.reason, "explicit");
+  assert.equal(result.schemaId, 'backend-api');
+  assert.equal(result.reason, 'explicit');
 });
 
-test("resolveInitSchemaSelection keeps existing default in interactive mode", async () => {
+test('resolveInitSchemaSelection keeps existing default in interactive mode', async () => {
   const result = await resolveInitSchemaSelection({
-    existingDefaultSchema: "frontend-product",
-    availableSchemaIds: ["frontend-product", "spec-driven"],
+    existingDefaultSchema: 'frontend-product',
+    availableSchemaIds: ['frontend-product', 'spec-driven'],
     interactive: true,
     confirmKeepExisting: async () => true,
-    promptSelectSchema: async () => "spec-driven",
+    promptSelectSchema: async () => 'spec-driven',
   });
-  assert.equal(result.schemaId, "frontend-product");
-  assert.equal(result.reason, "existing-default-kept");
+  assert.equal(result.schemaId, 'frontend-product');
+  assert.equal(result.reason, 'existing-default-kept');
 });
 
-test("resolveInitSchemaSelection uses fallback in non-interactive mode", async () => {
+test('resolveInitSchemaSelection uses fallback in non-interactive mode', async () => {
   const result = await resolveInitSchemaSelection({
-    availableSchemaIds: ["spec-driven", "backend-api"],
+    availableSchemaIds: ['spec-driven', 'backend-api'],
     interactive: false,
   });
-  assert.equal(result.schemaId, "spec-driven");
-  assert.equal(result.reason, "non-interactive-fallback");
+  assert.equal(result.schemaId, 'spec-driven');
+  assert.equal(result.reason, 'non-interactive-fallback');
 });
 
-test("discoverSchemaTemplates returns bundled and project schemas", () =>
+test('discoverSchemaTemplates returns bundled and project schemas', () =>
   withTempDir((root) => {
-    const projectRoot = path.join(root, "project");
-    const packageRoot = path.join(root, "package");
-    const bundledDir = path.join(packageRoot, "src", "schemas");
-    fs.mkdirSync(path.join(projectRoot, "schemas"), { recursive: true });
+    const projectRoot = path.join(root, 'project');
+    const packageRoot = path.join(root, 'package');
+    const bundledDir = path.join(packageRoot, 'src', 'schemas');
+    fs.mkdirSync(path.join(projectRoot, 'schemas'), { recursive: true });
     fs.mkdirSync(bundledDir, { recursive: true });
 
-    writeSchema(bundledDir, "spec-driven");
-    writeSchema(path.join(projectRoot, "schemas"), "custom-team");
+    writeSchema(bundledDir, 'spec-driven');
+    writeSchema(path.join(projectRoot, 'schemas'), 'custom-team');
 
     const schemas = discoverSchemaTemplates({ projectRoot, packageRoot, bundledDir });
     const ids = schemas.map((s) => s.id);
-    assert.deepEqual(ids, ["custom-team", "spec-driven"]);
+    assert.deepEqual(ids, ['custom-team', 'spec-driven']);
   }));
 
-test("discoverSchemaTemplates fails on duplicate IDs", () =>
+test('discoverSchemaTemplates fails on duplicate IDs', () =>
   withTempDir((root) => {
-    const projectRoot = path.join(root, "project");
-    const packageRoot = path.join(root, "package");
-    const bundledDir = path.join(packageRoot, "src", "schemas");
-    fs.mkdirSync(path.join(projectRoot, "schemas"), { recursive: true });
+    const projectRoot = path.join(root, 'project');
+    const packageRoot = path.join(root, 'package');
+    const bundledDir = path.join(packageRoot, 'src', 'schemas');
+    fs.mkdirSync(path.join(projectRoot, 'schemas'), { recursive: true });
     fs.mkdirSync(bundledDir, { recursive: true });
 
-    writeSchema(bundledDir, "spec-driven");
-    writeSchema(path.join(projectRoot, "schemas"), "spec-driven");
+    writeSchema(bundledDir, 'spec-driven');
+    writeSchema(path.join(projectRoot, 'schemas'), 'spec-driven');
 
     assert.throws(
       () => discoverSchemaTemplates({ projectRoot, packageRoot, bundledDir }),
-      /Schema ID conflict/
+      /Schema ID conflict/,
     );
   }));
 
-test("project config read/write round-trip", () =>
+test('project config read/write round-trip', () =>
   withTempDir((projectRoot) => {
-    writeProjectConfig(projectRoot, { defaultSchemaTemplateId: "devops-platform" });
+    writeProjectConfig(projectRoot, { defaultSchemaTemplateId: 'devops-platform' });
     const cfg = readProjectConfig(projectRoot);
-    assert.equal(cfg.defaultSchemaTemplateId, "devops-platform");
+    assert.equal(cfg.defaultSchemaTemplateId, 'devops-platform');
   }));

package/scripts/install-environments.js

@@ -17,7 +17,14 @@ function parseTools(value) {
   const raw = (value ?? 'all').trim().toLowerCase();
   if (raw === 'none') return [];
   if (raw === 'all') return [...SUPPORTED_TOOLS];
-  return [...new Set(raw.split(',').map(p => normalizeToolId(p.trim())).filter(Boolean))];
+  return [
+    ...new Set(
+      raw
+        .split(',')
+        .map((p) => normalizeToolId(p.trim()))
+        .filter(Boolean),
+    ),
+  ];
 }
 
 function defaultCommandExists(command) {
@@ -36,7 +43,7 @@ function buildDetectionContext(projectRoot, overrides = {}) {
 }
 
 function createDetectedEnvironment(id, signals) {
-  const detected = signals.some(signal => signal.present);
+  const detected = signals.some((signal) => signal.present);
   return { id, detected, signals };
 }
 
@@ -46,7 +53,11 @@ function detectCodex(context) {
     : path.join(context.homedir, '.codex');
   return createDetectedEnvironment('codex', [
     { kind: 'binary', name: 'codex', present: context.commandExists('codex') },
-    { kind: 'directory', name: path.join(context.projectRoot, '.codex'), present: context.pathExists(path.join(context.projectRoot, '.codex')) },
+    {
+      kind: 'directory',
+      name: path.join(context.projectRoot, '.codex'),
+      present: context.pathExists(path.join(context.projectRoot, '.codex')),
+    },
     { kind: 'directory', name: codexHome, present: context.pathExists(codexHome) },
   ]);
 }
@@ -54,8 +65,16 @@ function detectCodex(context) {
 function detectClaudeCode(context) {
   return createDetectedEnvironment('claudecode', [
     { kind: 'binary', name: 'claude', present: context.commandExists('claude') },
-    { kind: 'directory', name: path.join(context.projectRoot, '.claude'), present: context.pathExists(path.join(context.projectRoot, '.claude')) },
-    { kind: 'directory', name: path.join(context.homedir, '.claude'), present: context.pathExists(path.join(context.homedir, '.claude')) },
+    {
+      kind: 'directory',
+      name: path.join(context.projectRoot, '.claude'),
+      present: context.pathExists(path.join(context.projectRoot, '.claude')),
+    },
+    {
+      kind: 'directory',
+      name: path.join(context.homedir, '.claude'),
+      present: context.pathExists(path.join(context.homedir, '.claude')),
+    },
   ]);
 }
 
@@ -69,13 +88,13 @@ function getEnvironmentDetectors() {
 function detectEnvironments(projectRoot, overrides = {}) {
   const context = buildDetectionContext(projectRoot, overrides);
   const detectors = getEnvironmentDetectors();
-  return SUPPORTED_TOOLS.map(tool => detectors[tool].detect(context));
+  return SUPPORTED_TOOLS.map((tool) => detectors[tool].detect(context));
 }
 
 function detectInstalledTools(projectRoot, overrides = {}) {
   return detectEnvironments(projectRoot, overrides)
-    .filter(result => result.detected)
-    .map(result => result.id);
+    .filter((result) => result.detected)
+    .map((result) => result.id);
 }
 
 function getToolAdapters() {

package/scripts/install-environments.test.js

@@ -13,7 +13,7 @@ const HOME_DIR = '/home/tester';
 
 function detectionHarness({ commands = [], paths = [] } = {}) {
   const commandSet = new Set(commands);
-  const pathSet = new Set(paths.map(p => path.resolve(p)));
+  const pathSet = new Set(paths.map((p) => path.resolve(p)));
   return {
     commandExists: (command) => commandSet.has(command),
     pathExists: (targetPath) => pathSet.has(path.resolve(targetPath)),
@@ -23,23 +23,32 @@ function detectionHarness({ commands = [], paths = [] } = {}) {
 }
 
 test('detectInstalledTools returns claudecode when only Claude signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['claude'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['claude'],
+    }),
+  );
   assert.deepEqual(detected, ['claudecode']);
 });
 
 test('detectInstalledTools returns codex when only Codex signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['codex'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['codex'],
+    }),
+  );
   assert.deepEqual(detected, ['codex']);
 });
 
 test('detectInstalledTools returns both tools when both signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['codex', 'claude'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['codex', 'claude'],
+    }),
+  );
   assert.deepEqual(detected, ['codex', 'claudecode']);
 });
 

package/scripts/install-skills.js

@@ -2,15 +2,11 @@
 
 const path = require('path');
 const fs = require('fs');
-const {
-  parseTools,
-  getToolAdapter,
-  detectEnvironments,
-} = require('./install-environments');
+const { parseTools, getToolAdapter, detectEnvironments } = require('./install-environments');
 
 const MANAGED_BEGIN = '<!-- DEVFLOW:BEGIN ';
 const MANAGED_END = '<!-- DEVFLOW:END ';
-const COMMAND_SET = ['new', 'continue', 'status', 'promote', 'develop', 'archive'];
+const COMMAND_SET = ['new', 'continue', 'status', 'promote', 'develop', 'archive', 'schema'];
 
 function resolveToolDirs(projectRoot, tool) {
   return getToolAdapter(tool).resolveTargets(projectRoot);
@@ -138,6 +134,44 @@ function renderSkill(tool, command, markerId) {
       '4. Call `archive_spec`.',
       '5. Report success and the archive path.',
     ],
+    schema: [
+      `# Skill: /df:schema`,
+      '',
+      `Use this skill to interactively create a custom DevFlow schema in ${agentName}.`,
+      '',
+      '## Steps (in order)',
+      '',
+      '1. Call `list_schemas` and show the user what schemas are already available.',
+      '   If one fits their needs, suggest using it directly.',
+      '2. Ask what kind of project/workflow they need (e.g. mobile app, ML pipeline,',
+      '   infrastructure, documentation, data engineering, security review, etc.).',
+      '3. Based on the project type, ask which artifacts/documents their workflow',
+      '   should include. Suggest sensible defaults. Common options:',
+      '   - Proposal / RFC',
+      '   - Requirements / Specifications',
+      '   - Architecture / Design doc',
+      '   - Security review',
+      '   - Testing plan / Test strategy',
+      '   - Migration plan',
+      '   - Deployment / Runbook',
+      '   - Implementation tasks',
+      '4. Design the artifact dependency DAG — which artifacts must be approved',
+      '   before others can be written. Present the DAG to the user for confirmation.',
+      '5. Ask about quality rules:',
+      '   - RFC 2119 keywords enforced (MUST/SHOULD/MAY)?',
+      '   - Minimum scenarios per requirement (suggest 1-2)?',
+      '6. Generate well-structured markdown templates for each artifact.',
+      '7. Call `create_schema` with name, artifacts, qualityRules, apply, and templates.',
+      '8. Report the schema was created and how to use it:',
+      '   - `create_spec` with `schema: "<name>"`',
+      '   - Or set as default in `devflow/project-config.json`',
+      '',
+      '## Guidelines',
+      '- Keep artifact IDs short and kebab-case (e.g. "security-review", "test-plan")',
+      '- Template filenames should match: `<artifact-id>.md`',
+      '- Always include a final "tasks" artifact that depends on the key artifacts',
+      '- The `apply.requires` should include at minimum the tasks artifact',
+    ],
   };
 
   const lines = bodies[command];
@@ -147,9 +181,10 @@ function renderSkill(tool, command, markerId) {
 
 function renderCommand(tool, command, markerId) {
   const commandName = `/df:${command}`;
-  const codexHeader = tool === 'codex'
-    ? ['---', `description: DevFlow ${commandName} workflow action`, '---', '']
-    : [];
+  const codexHeader =
+    tool === 'codex'
+      ? ['---', `description: DevFlow ${commandName} workflow action`, '---', '']
+      : [];
 
   const bodies = {
     new: [
@@ -262,6 +297,24 @@ function renderCommand(tool, command, markerId) {
       '4. Call `archive_spec`.',
       '5. Report success and the archive path.',
     ],
+    schema: [
+      `# ${commandName}`,
+      '',
+      'Interactively create a custom DevFlow schema.',
+      '',
+      '## Steps (in order)',
+      '',
+      '1. Call `list_schemas` and show available schemas. If one fits, suggest it.',
+      '2. Ask what kind of project/workflow the user needs.',
+      '3. Ask which artifacts/documents their workflow should include.',
+      '4. Design the artifact dependency DAG. Present it for confirmation.',
+      '5. Ask about quality rules (RFC 2119, min scenarios per requirement).',
+      '6. Generate markdown templates for each artifact.',
+      '7. Call `create_schema` with name, artifacts, qualityRules, apply, and templates.',
+      '8. Report the schema was created and how to use it:',
+      '   - `create_spec` with `schema: "<name>"`',
+      '   - Or set as default in `devflow/project-config.json`',
+    ],
   };
 
   const bodyLines = bodies[command];
@@ -273,7 +326,7 @@ function replaceManagedSection(existing, markerId, nextContent) {
   const escaped = markerId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const pattern = new RegExp(
     `<!-- DEVFLOW:BEGIN ${escaped} -->[\\s\\S]*?<!-- DEVFLOW:END ${escaped} -->\\n?`,
-    'm'
+    'm',
   );
   if (!pattern.test(existing)) return null;
   return existing.replace(pattern, nextContent);
@@ -300,7 +353,9 @@ function buildAssets(projectRoot, tools, delivery) {
       const commandMarker = `${tool}:command:df-${command}`;
       if (delivery !== 'commands') {
         assets.push({
-          tool, kind: 'skill', command,
+          tool,
+          kind: 'skill',
+          command,
           outputPath: path.join(dirs.skillsDir, `df-${command}.md`),
           markerId: skillMarker,
           content: renderSkill(tool, command, skillMarker),
@@ -308,7 +363,9 @@ function buildAssets(projectRoot, tools, delivery) {
       }
       if (delivery !== 'skills') {
         assets.push({
-          tool, kind: 'command', command,
+          tool,
+          kind: 'command',
+          command,
           outputPath: path.join(dirs.commandsDir, `df-${command}.md`),
           markerId: commandMarker,
           content: renderCommand(tool, command, commandMarker),
@@ -329,7 +386,7 @@ function selectTools(projectRoot, options) {
   } else if (options.tools !== undefined) {
     selectedTools = parseTools(options.tools);
   } else if (autodetect) {
-    selectedTools = detection.filter(d => d.detected).map(d => d.id);
+    selectedTools = detection.filter((d) => d.detected).map((d) => d.id);
   } else {
     selectedTools = parseTools('all');
   }
@@ -354,17 +411,17 @@ function installSkills(projectRoot, options = {}) {
     dryRun,
     autodetect: selection.autodetect,
     selectedTools: selection.selectedTools,
-    environments: selection.detection.map(d => ({
+    environments: selection.detection.map((d) => ({
       tool: d.id,
       detected: d.detected,
-      status: selection.selectedTools.includes(d.id)
-        ? (dryRun ? 'planned' : 'pending')
-        : 'skipped',
+      status: selection.selectedTools.includes(d.id) ? (dryRun ? 'planned' : 'pending') : 'skipped',
       reason: selection.selectedTools.includes(d.id)
         ? undefined
-        : (selection.autodetect && options.tools === undefined && !options.only
-          ? (d.detected ? 'not-selected' : 'not-detected')
-          : 'not-selected'),
+        : selection.autodetect && options.tools === undefined && !options.only
+          ? d.detected
+            ? 'not-selected'
+            : 'not-detected'
+          : 'not-selected',
       created: 0,
       updated: 0,
       skipped: 0,
@@ -378,7 +435,7 @@ function installSkills(projectRoot, options = {}) {
 
   for (const asset of assets) {
     const { outputPath, markerId, content, tool } = asset;
-    const envReport = report.environments.find(e => e.tool === tool);
+    const envReport = report.environments.find((e) => e.tool === tool);
     const displayPath = path.relative(projectRoot, outputPath);
     try {
       const alreadyExists = exists(outputPath);
@@ -393,7 +450,11 @@ function installSkills(projectRoot, options = {}) {
             }
             report.updated++;
             if (envReport) envReport.updated++;
-            report.results.push({ ...asset, path: displayPath, action: dryRun ? 'would_update' : 'updated' });
+            report.results.push({
+              ...asset,
+              path: displayPath,
+              action: dryRun ? 'would_update' : 'updated',
+            });
           } else {
             report.skipped++;
             if (envReport) envReport.skipped++;
@@ -403,7 +464,7 @@ function installSkills(projectRoot, options = {}) {
         }
 
         const ownershipError = new Error(
-          `Refusing to modify unmanaged file for ${tool}: ${displayPath}`
+          `Refusing to modify unmanaged file for ${tool}: ${displayPath}`,
         );
         ownershipError.code = 'UNMANAGED_FILE';
         throw ownershipError;
@@ -414,7 +475,11 @@ function installSkills(projectRoot, options = {}) {
       }
       report.created++;
       if (envReport) envReport.created++;
-      report.results.push({ ...asset, path: displayPath, action: dryRun ? 'would_create' : 'created' });
+      report.results.push({
+        ...asset,
+        path: displayPath,
+        action: dryRun ? 'would_create' : 'created',
+      });
     } catch (error) {
       report.failed++;
       if (envReport) envReport.failed++;
@@ -432,7 +497,8 @@ function installSkills(projectRoot, options = {}) {
     if (!selection.selectedTools.includes(envReport.tool)) continue;
     if (envReport.failed > 0) {
       envReport.status = 'failed';
-      envReport.reason = envReport.created + envReport.updated > 0 ? 'partial-failure' : 'install-failed';
+      envReport.reason =
+        envReport.created + envReport.updated > 0 ? 'partial-failure' : 'install-failed';
     } else if (dryRun) {
       envReport.status = 'planned';
     } else {
@@ -449,22 +515,29 @@ function printReport(report) {
     for (const env of report.environments) {
       const statusDetails = env.reason ? `${env.status} (${env.reason})` : env.status;
       const detectedText = env.detected ? 'detected' : 'not detected';
-      console.log(`  - ${env.tool}: ${statusDetails}; ${detectedText}; created=${env.created} updated=${env.updated} skipped=${env.skipped} failed=${env.failed}`);
+      console.log(
+        `  - ${env.tool}: ${statusDetails}; ${detectedText}; created=${env.created} updated=${env.updated} skipped=${env.skipped} failed=${env.failed}`,
+      );
     }
     console.log('');
   }
 
   for (const r of report.results) {
     const icon =
-      r.action === 'created' || r.action === 'would_create' ? '✓' :
-      r.action === 'updated' || r.action === 'would_update' ? '↻' :
-      r.action === 'failed' ? '✗' :
-      '–';
+      r.action === 'created' || r.action === 'would_create'
+        ? '✓'
+        : r.action === 'updated' || r.action === 'would_update'
+          ? '↻'
+          : r.action === 'failed'
+            ? '✗'
+            : '–';
     const errorSuffix = r.action === 'failed' ? ` - ${r.error}` : '';
     console.log(`  ${icon} [${r.tool}] ${r.kind} ${r.path} (${r.action})${errorSuffix}`);
   }
   const mode = report.dryRun ? ' (dry-run)' : '';
-  console.log(`\n  ${report.created} created, ${report.updated} updated, ${report.skipped} skipped, ${report.failed} failed${mode}`);
+  console.log(
+    `\n  ${report.created} created, ${report.updated} updated, ${report.skipped} skipped, ${report.failed} failed${mode}`,
+  );
 }
 
 // CLI usage: node scripts/install-skills.js [--tools all|codex|claudecode] [--delivery both|skills|commands] [--force]