worclaude 2.8.0 → 2.9.0

package/src/commands/init.js

@@ -6,9 +6,9 @@ import {
   scaffoldAgentsMd,
   updateGitignore,
   scaffoldHooks,
-  scaffoldPluginJson,
-  scaffoldMemoryDocs,
+  scaffoldScripts,
 } from '../core/scaffolder.js';
+import { OPTIONAL_FEATURES } from '../data/optional-features.js';
 import {
   computeFileHashes,
   createWorkflowMeta,
@@ -34,7 +34,7 @@ import {
   CONFIRMATION_STEPS,
   SPEC_MD_TEMPLATE_MAP,
 } from '../data/agents.js';
-import { buildAgentRoutingSkill } from '../generators/agent-routing.js';
+import { buildAgentRoutingSkill, loadShippedAgents } from '../generators/agent-routing.js';
 import { buildCommandsBlock } from '../core/variables.js';
 
 // --- Helper functions ---
@@ -70,34 +70,61 @@ async function runTechStack(selections) {
 }
 
 async function runAgents(selections) {
-  const selectedAgents = await promptAgentSelection(selections.projectTypes);
-  return { ...selections, selectedAgents };
+  const result = await promptAgentSelection(selections.projectTypes);
+  return {
+    ...selections,
+    selectedAgents: result.selectedAgents,
+    selectedCategories: result.selectedCategories,
+    additionalCategories: result.additionalCategories,
+    preSelectedCategories: result.preSelectedCategories,
+  };
 }
 
 async function runOptionalExtras(selections) {
-  const { generatePluginJson, scaffoldGtdMemory } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'generatePluginJson',
-      message: 'Generate .claude-plugin/plugin.json for marketplace compatibility?',
-      choices: [
-        { name: 'Yes', value: true },
-        { name: 'No', value: false },
-      ],
-      default: selections.generatePluginJson === true ? 0 : 1,
-    },
+  const previouslySelected = new Set(selections.optionalFeatures || []);
+  const questions = OPTIONAL_FEATURES.map((feature) => ({
+    type: 'list',
+    name: feature.id,
+    message: feature.label,
+    choices: [
+      { name: 'Yes', value: true },
+      { name: 'No', value: false },
+    ],
+    default: previouslySelected.has(feature.id) ? 0 : 1,
+  }));
+  const answers = await inquirer.prompt(questions);
+  const optionalFeatures = OPTIONAL_FEATURES.filter((f) => answers[f.id]).map((f) => f.id);
+
+  // GitHub Action (`@claude` PR-comment workflow). Worclaude does NOT run
+  // the install — Claude Code provides /install-github-action and we point
+  // at it. Phase 7 T7.3.
+  const { installGithubAction } = await inquirer.prompt([
     {
       type: 'list',
-      name: 'scaffoldGtdMemory',
-      message: 'Scaffold structured memory files (decisions.md, preferences.md)?',
+      name: 'installGithubAction',
+      message:
+        'Install Claude Code\'s GitHub Action for the @claude "compounding engineering" workflow?',
       choices: [
-        { name: 'Yes', value: true },
-        { name: 'No', value: false },
+        { name: 'Yes — show me the install instructions now', value: true },
+        { name: "No — I'll do it later", value: false },
       ],
-      default: selections.scaffoldGtdMemory === true ? 0 : 1,
+      default: 1,
     },
   ]);
-  return { ...selections, generatePluginJson, scaffoldGtdMemory };
+
+  return { ...selections, optionalFeatures, installGithubAction };
+}
+
+function displayGithubActionHint(selections) {
+  if (!selections.installGithubAction) return;
+  display.newline();
+  display.barLine('GitHub Action setup:');
+  display.barLine(
+    `  Run ${display.white('/install-github-action')} inside Claude Code to enable the @claude workflow.`
+  );
+  display.barLine(
+    `  See ${display.dimColor('docs/guide/claude-code-integration.md#github-action-integration-claude-pattern')} for details.`
+  );
 }
 
 const STEP_RUNNERS = {
@@ -142,9 +169,8 @@ async function showConfirmation(selections) {
     `  ${'Agents'.padEnd(10)}${display.white(`${universalCount} universal + ${optionalCount} optional`)} ${display.dimColor(`(${totalCount} total)`)}`
   );
 
-  const extrasLabels = [];
-  if (selections.generatePluginJson) extrasLabels.push('plugin.json');
-  if (selections.scaffoldGtdMemory) extrasLabels.push('memory docs');
+  const opted = new Set(selections.optionalFeatures || []);
+  const extrasLabels = OPTIONAL_FEATURES.filter((f) => opted.has(f.id)).map((f) => f.extrasLabel);
   if (extrasLabels.length > 0) {
     console.log(`  ${'Extras'.padEnd(10)}${display.white(extrasLabels.join(', '))}`);
   }
@@ -177,8 +203,7 @@ function createInitialSelections(projectRoot) {
     languages: [],
     useDocker: false,
     selectedAgents: [],
-    generatePluginJson: false,
-    scaffoldGtdMemory: false,
+    optionalFeatures: [],
   };
 }
 
@@ -263,7 +288,7 @@ function buildTemplateVariables(selections) {
   );
   const skillsText = skillsLines.join('\n');
 
-  const memoryArchitectureExtras = selections.scaffoldGtdMemory
+  const memoryArchitectureExtras = (selections.optionalFeatures || []).includes('gtd-memory')
     ? '\n- Team decisions: `docs/memory/decisions.md` (version-controlled, shared).\n- Team preferences: `docs/memory/preferences.md` (version-controlled, shared).'
     : '';
 
@@ -281,6 +306,56 @@ function buildTemplateVariables(selections) {
   };
 }
 
+export function buildInstallationRationale(selections) {
+  const projectTypes = selections.projectTypes || [];
+  const preSelected = new Set(selections.preSelectedCategories || []);
+  const picked = new Set(selections.selectedCategories || []);
+  const added = selections.additionalCategories || [];
+
+  const autoMatched = [...picked].filter((c) => preSelected.has(c));
+  const removedAuto = [...preSelected].filter((c) => !picked.has(c));
+  const manualPicked = [...picked].filter((c) => !preSelected.has(c));
+
+  const decisions = [];
+  if (autoMatched.length > 0) {
+    decisions.push(
+      `Accepted auto-recommended categories from project type(s) ${projectTypes.join(', ') || '(none)'}: ${autoMatched.join(', ')}.`
+    );
+  }
+  if (removedAuto.length > 0) {
+    decisions.push(`Removed auto-recommended categories: ${removedAuto.join(', ')}.`);
+  }
+  if (manualPicked.length > 0) {
+    decisions.push(
+      `Added categories beyond the project-type recommendations: ${manualPicked.join(', ')}.`
+    );
+  }
+  if (added.length > 0) {
+    decisions.push(`Opted into extra categories at the second prompt: ${added.join(', ')}.`);
+  }
+
+  let rationale;
+  if (
+    autoMatched.length > 0 &&
+    removedAuto.length === 0 &&
+    manualPicked.length === 0 &&
+    added.length === 0
+  ) {
+    rationale = `Auto-selected from project type(s) '${projectTypes.join(', ')}'.`;
+  } else if (decisions.length === 0) {
+    rationale = 'No optional categories selected.';
+  } else {
+    rationale = decisions.join(' ');
+  }
+
+  return {
+    projectTypes,
+    selectedCategories: [...picked, ...added],
+    rationale,
+    userDecisions: decisions,
+  };
+}
+
 async function computeAndWriteWorkflowMeta(projectRoot, selections, version) {
   const fileHashes = await computeFileHashes(projectRoot);
 
@@ -292,6 +367,11 @@ async function computeAndWriteWorkflowMeta(projectRoot, selections, version) {
     optionalAgents: selections.selectedAgents,
     useDocker: selections.useDocker || false,
     fileHashes,
+    installation: buildInstallationRationale(selections),
+    optionalFeatures: selections.optionalFeatures || [],
+    optedOutFeatures: OPTIONAL_FEATURES.filter(
+      (f) => !(selections.optionalFeatures || []).includes(f.id)
+    ).map((f) => f.id),
   });
   await writeWorkflowMeta(projectRoot, meta);
 }
@@ -368,7 +448,7 @@ async function scaffoldFresh(projectRoot, selections, variables, settingsStr, ve
     }
     spinner.text = `Created ${TEMPLATE_SKILLS.length} template skills`;
 
-    const agentRoutingContent = buildAgentRoutingSkill(selectedAgents, projectTypes);
+    const agentRoutingContent = buildAgentRoutingSkill(await loadShippedAgents(selectedAgents));
     await writeFile(
       path.join(projectRoot, '.claude', 'skills', 'agent-routing', 'SKILL.md'),
       agentRoutingContent
@@ -417,20 +497,33 @@ async function scaffoldFresh(projectRoot, selections, variables, settingsStr, ve
     await scaffoldHooks(projectRoot);
     spinner.text = 'Created .claude/hooks/';
 
+    // Copy slash-command helper scripts (.claude/scripts/)
+    await scaffoldScripts(projectRoot);
+    spinner.text = 'Created .claude/scripts/';
+
     // Create learnings directory for correction capture
     await writeFile(path.join(projectRoot, '.claude', 'learnings', '.gitkeep'), '');
     spinner.text = 'Created .claude/learnings/';
 
-    // Opt-in: plugin.json for Claude Code marketplace compatibility
-    if (selections.generatePluginJson) {
-      await scaffoldPluginJson(projectRoot, selections);
-      spinner.text = 'Created .claude-plugin/plugin.json';
-    }
-
-    // Opt-in: GTD memory scaffold (docs/memory/decisions.md, preferences.md)
-    if (selections.scaffoldGtdMemory) {
-      await scaffoldMemoryDocs(projectRoot);
-      spinner.text = 'Created docs/memory/';
+    // Create scratch directory for SHA-keyed transient artifacts (gitignored)
+    await writeFile(path.join(projectRoot, '.claude', 'scratch', '.gitkeep'), '');
+    spinner.text = 'Created .claude/scratch/';
+
+    // Create plans directory for active work guidance (tracked)
+    await writeFile(path.join(projectRoot, '.claude', 'plans', '.gitkeep'), '');
+    spinner.text = 'Created .claude/plans/';
+
+    // Create observability directory for hook-captured event logs (gitignored)
+    await writeFile(path.join(projectRoot, '.claude', 'observability', '.gitkeep'), '');
+    spinner.text = 'Created .claude/observability/';
+
+    // Opt-in: scaffold each optional feature the user selected. Scaffolders
+    // are idempotent — if a file already exists they skip it.
+    const optedIn = new Set(selections.optionalFeatures || []);
+    for (const feature of OPTIONAL_FEATURES) {
+      if (!optedIn.has(feature.id)) continue;
+      await feature.scaffold(projectRoot, selections);
+      spinner.text = `Created ${feature.successPath}`;
     }
 
     await computeAndWriteWorkflowMeta(projectRoot, selections, version);
@@ -459,11 +552,16 @@ function displayFreshSuccess(selections, skipped) {
   display.success(`.claude/skills/${display.dimColor(`        ${totalSkills} skills`)}`);
   display.success('.claude/sessions/');
   display.success('.claude/hooks/');
-  if (selections.generatePluginJson) {
-    display.success('.claude-plugin/plugin.json');
-  }
-  if (selections.scaffoldGtdMemory) {
-    display.success('docs/memory/' + display.dimColor('           decisions.md, preferences.md'));
+  const optedIn = new Set(selections.optionalFeatures || []);
+  for (const feature of OPTIONAL_FEATURES) {
+    if (!optedIn.has(feature.id)) continue;
+    if (feature.successDetail) {
+      display.success(
+        `${feature.successPath}${display.dimColor(`           ${feature.successDetail}`)}`
+      );
+    } else {
+      display.success(feature.successPath);
+    }
   }
   display.success('.mcp.json');
   display.success('.gitignore');
@@ -706,6 +804,7 @@ export async function initCommand() {
     const { settingsStr } = await buildSettingsJson(selections.languages, selections.useDocker);
     const skipped = await scaffoldFresh(projectRoot, selections, variables, settingsStr, version);
     displayFreshSuccess(selections, skipped);
+    displayGithubActionHint(selections);
   } else {
     // Scenario B: merge
     const spinner = ora('Merging workflow...').start();
@@ -717,6 +816,7 @@ export async function initCommand() {
       await computeAndWriteWorkflowMeta(projectRoot, selections, version);
       spinner.succeed('Workflow merged successfully!');
       displayMergeReport(report, backupPath);
+      displayGithubActionHint(selections);
     } catch (err) {
       spinner.fail('Failed to merge workflow');
       display.error(err.message);

package/src/commands/observability.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { computeReport, renderMarkdown } from '../utils/observability.js';
+import * as display from '../utils/display.js';
+
+export async function observabilityCommand(options = {}) {
+  const projectRoot = process.cwd();
+  const report = await computeReport(projectRoot);
+
+  const output = options.json ? JSON.stringify(report, null, 2) : renderMarkdown(report);
+
+  if (options.out) {
+    const outPath = path.isAbsolute(options.out)
+      ? options.out
+      : path.join(projectRoot, options.out);
+    await fs.ensureDir(path.dirname(outPath));
+    await fs.writeFile(outPath, output);
+    display.success(`Wrote observability report to ${path.relative(projectRoot, outPath)}`);
+    return;
+  }
+
+  process.stdout.write(output);
+  if (!output.endsWith('\n')) process.stdout.write('\n');
+}

package/src/commands/regenerate-routing.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import {
+  buildAgentRoutingSkill,
+  regenerateAgentRoutingContent,
+} from '../generators/agent-routing.js';
+import { loadAgentsFromDir } from '../utils/agent-frontmatter.js';
+import * as display from '../utils/display.js';
+
+/**
+ * Regenerate `.claude/skills/agent-routing/SKILL.md` from the project's
+ * installed agent files. Preserves any user-authored prose that lives
+ * outside the AUTO-GENERATED markers.
+ *
+ * @param {string} projectRoot
+ * @returns {Promise<{regenerated: boolean, agentsDir: string, skillPath: string, count: number, reason?: string}>}
+ */
+export async function regenerateRoutingForProject(projectRoot) {
+  const agentsDir = path.join(projectRoot, '.claude', 'agents');
+  const skillDir = path.join(projectRoot, '.claude', 'skills', 'agent-routing');
+  const skillPath = path.join(skillDir, 'SKILL.md');
+
+  const agents = await loadAgentsFromDir(agentsDir);
+  if (agents.length === 0) {
+    return {
+      regenerated: false,
+      agentsDir,
+      skillPath,
+      count: 0,
+      reason: 'no agent files found',
+    };
+  }
+
+  let existing = null;
+  try {
+    existing = await readFile(skillPath, 'utf8');
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  const content = existing
+    ? regenerateAgentRoutingContent(existing, agents)
+    : buildAgentRoutingSkill(agents);
+
+  await mkdir(skillDir, { recursive: true });
+  await writeFile(skillPath, content, 'utf8');
+
+  return {
+    regenerated: true,
+    agentsDir,
+    skillPath,
+    count: agents.length,
+  };
+}
+
+export async function regenerateRoutingCommand() {
+  const projectRoot = process.cwd();
+  try {
+    const result = await regenerateRoutingForProject(projectRoot);
+    if (!result.regenerated) {
+      display.warn(`Skipped: ${result.reason} at ${path.relative(projectRoot, result.agentsDir)}/`);
+      return;
+    }
+    const rel = path.relative(projectRoot, result.skillPath);
+    display.success(`Regenerated ${rel} from ${result.count} agent file(s).`);
+  } catch (err) {
+    display.error(`Failed to regenerate agent-routing skill: ${err.message}`);
+    process.exitCode = 1;
+  }
+}

package/src/commands/status.js

@@ -73,6 +73,20 @@ export async function statusCommand() {
   display.barLine(`${'Skills'.padEnd(11)}${display.white(String(skillCount))}`);
   display.newline();
 
+  // Installation rationale (T3.6) — recorded at init time. Older installs
+  // pre-dating this field gracefully degrade: nothing surfaces.
+  if (meta.installation && meta.installation.rationale) {
+    display.info('Installation rationale:');
+    display.dim(`    ${meta.installation.rationale}`);
+    if (
+      Array.isArray(meta.installation.selectedCategories) &&
+      meta.installation.selectedCategories.length > 0
+    ) {
+      display.dim(`    Categories: ${meta.installation.selectedCategories.join(', ')}`);
+    }
+    display.newline();
+  }
+
   // Customized files
   const customized = [];
   for (const [key, storedHash] of Object.entries(meta.fileHashes || {})) {

package/src/commands/upgrade.js

@@ -26,6 +26,8 @@ import {
   patchAgentDescriptions,
   migrateWorkflowRefLocation,
 } from '../core/migration.js';
+import { regenerateRoutingForProject } from './regenerate-routing.js';
+import { availableOptionalFeatures } from '../data/optional-features.js';
 
 const CONFLICT_CHECK_TYPES = new Set(['hook', 'root-file']);
 
@@ -323,12 +325,63 @@ async function runRepairOnlyFlow({
       display.newline();
       display.barLine(`Review files under .claude/workflow-ref/ and merge what's useful.`);
     }
+
+    const features = await promptAndScaffoldOptionalFeatures(projectRoot, meta, { yes, dryRun });
+    if (features.scaffolded.length + features.declined.length > 0) {
+      await writeWorkflowMeta(projectRoot, meta);
+    }
   } catch (err) {
     spinner.fail('Repair failed.');
     display.error(err.message);
   }
 }
 
+async function promptAndScaffoldOptionalFeatures(projectRoot, meta, { yes, dryRun }) {
+  const empty = { scaffolded: [], declined: [] };
+  if (yes || dryRun) return empty;
+
+  const available = await availableOptionalFeatures(projectRoot, meta);
+  if (available.length === 0) return empty;
+
+  const upgradeSelections = {
+    projectName: path.basename(projectRoot),
+    selectedAgents: meta.optionalAgents || [],
+  };
+
+  display.newline();
+  display.barLine('Optional features available:');
+
+  const scaffolded = [];
+  const declined = [];
+
+  for (const feature of available) {
+    const { accept } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'accept',
+        message: feature.label,
+        choices: [
+          { name: 'Yes', value: true },
+          { name: 'No, skip (will not ask again)', value: false },
+        ],
+      },
+    ]);
+
+    if (accept) {
+      await feature.scaffold(projectRoot, upgradeSelections);
+      scaffolded.push(feature.id);
+      display.success(feature.successPath);
+    } else {
+      declined.push(feature.id);
+    }
+  }
+
+  meta.optionalFeatures = [...new Set([...(meta.optionalFeatures || []), ...scaffolded])];
+  meta.optedOutFeatures = [...new Set([...(meta.optedOutFeatures || []), ...declined])];
+
+  return { scaffolded, declined };
+}
+
 export async function upgradeCommand(options = {}) {
   const { dryRun = false, yes = false, repairOnly = false } = options;
   const projectRoot = process.cwd();
@@ -402,7 +455,14 @@ export async function upgradeCommand(options = {}) {
 
   // Version match + no repair + no template work + no ref relocation → up to date.
   if (versionMatch && !repairWork && !templateWork && !refWork) {
-    display.success(`Already up to date (v${currentVersion}).`);
+    const features = await promptAndScaffoldOptionalFeatures(projectRoot, meta, { yes, dryRun });
+    if (features.scaffolded.length + features.declined.length > 0) {
+      meta.lastUpdated = new Date().toISOString();
+      await writeWorkflowMeta(projectRoot, meta);
+    }
+    if (features.scaffolded.length === 0) {
+      display.success(`Already up to date (v${currentVersion}).`);
+    }
     return;
   }
 
@@ -528,6 +588,15 @@ export async function upgradeCommand(options = {}) {
     // Ensure sessions directory exists for session persistence
     await writeFile(path.join(projectRoot, '.claude', 'sessions', '.gitkeep'), '');
 
+    // Ensure scratch directory exists for SHA-keyed transient artifacts (gitignored)
+    await writeFile(path.join(projectRoot, '.claude', 'scratch', '.gitkeep'), '');
+
+    // Ensure plans directory exists for active work guidance (tracked)
+    await writeFile(path.join(projectRoot, '.claude', 'plans', '.gitkeep'), '');
+
+    // Ensure observability directory exists for hook-captured event logs (gitignored)
+    await writeFile(path.join(projectRoot, '.claude', 'observability', '.gitkeep'), '');
+
     // Hash refresh — files we just wrote (repair restored, repair migrated,
     // autoUpdate, templateNewFiles). Modified / conflict / unchanged /
     // userAdded / missingUntracked keep their prior hash; missingUntracked
@@ -548,6 +617,18 @@ export async function upgradeCommand(options = {}) {
 
     await updateGitignore(projectRoot);
 
+    try {
+      const routingResult = await regenerateRoutingForProject(projectRoot);
+      if (routingResult.regenerated) {
+        const rel = path.relative(projectRoot, routingResult.skillPath);
+        if (rel in fileHashes || (await fs.pathExists(routingResult.skillPath))) {
+          fileHashes[rel] = await hashFile(routingResult.skillPath);
+        }
+      }
+    } catch (err) {
+      display.warn(`agent-routing regeneration skipped: ${err.message}`);
+    }
+
     meta.version = currentVersion;
     meta.lastUpdated = new Date().toISOString();
     meta.fileHashes = fileHashes;
@@ -619,6 +700,11 @@ export async function upgradeCommand(options = {}) {
       display.newline();
       display.barLine(`Review files under .claude/workflow-ref/ and merge what's useful.`);
     }
+
+    const features = await promptAndScaffoldOptionalFeatures(projectRoot, meta, { yes, dryRun });
+    if (features.scaffolded.length + features.declined.length > 0) {
+      await writeWorkflowMeta(projectRoot, meta);
+    }
   } catch (err) {
     spinner.fail('Upgrade failed.');
     display.error(err.message);

package/src/commands/worktrees.js

@@ -0,0 +1,90 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import * as display from '../utils/display.js';
+
+function runGit(cwd, args) {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  return {
+    status: result.status,
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+  };
+}
+
+async function listWorktreeDirs(worktreesDir) {
+  const entries = await fs.readdir(worktreesDir).catch(() => []);
+  const dirs = [];
+  for (const name of entries) {
+    if (name.startsWith('.')) continue;
+    const full = path.join(worktreesDir, name);
+    const stat = await fs.stat(full).catch(() => null);
+    if (stat && stat.isDirectory()) dirs.push({ name, full });
+  }
+  return dirs;
+}
+
+export async function worktreesCleanCommand(options = {}) {
+  const projectRoot = options.path || process.cwd();
+  const worktreesDir = path.join(projectRoot, '.claude', 'worktrees');
+
+  if (!(await fs.pathExists(worktreesDir))) {
+    display.info('No .claude/worktrees/ directory — nothing to clean.');
+    return;
+  }
+
+  const dirs = await listWorktreeDirs(worktreesDir);
+  if (dirs.length === 0) {
+    display.info('.claude/worktrees/ is empty — nothing to clean.');
+    return;
+  }
+
+  display.info(`Found ${dirs.length} worktree entr${dirs.length === 1 ? 'y' : 'ies'}.`);
+  display.newline();
+
+  const removed = [];
+  const failed = [];
+
+  for (const { name, full } of dirs) {
+    // `git worktree remove -f -f` force-removes locked worktrees. The double
+    // `-f` is required because the first `-f` only overrides the lock check,
+    // and the second overrides "the worktree contains modifications" check.
+    const removeResult = runGit(projectRoot, ['worktree', 'remove', '-f', '-f', full]);
+
+    if (removeResult.status === 0) {
+      removed.push(name);
+      display.success(`Removed ${name}`);
+      continue;
+    }
+
+    // git worktree remove may fail when the worktree is unregistered (the
+    // directory exists but git no longer tracks it). Fall back to rm + prune.
+    const rmResult = await fs.remove(full).then(
+      () => ({ ok: true }),
+      (err) => ({ ok: false, err })
+    );
+    if (rmResult.ok) {
+      runGit(projectRoot, ['worktree', 'prune']);
+      removed.push(name);
+      display.success(`Removed ${name} (orphaned, fs cleanup)`);
+    } else {
+      failed.push({ name, reason: removeResult.stderr || rmResult.err?.message });
+      display.warn(`Failed to remove ${name}: ${removeResult.stderr || rmResult.err?.message}`);
+    }
+  }
+
+  display.newline();
+  display.info(
+    `Cleaned ${removed.length}/${dirs.length} worktrees${
+      failed.length > 0 ? ` (${failed.length} failed)` : ''
+    }.`
+  );
+
+  if (failed.length > 0) {
+    process.exitCode = 1;
+  }
+}

package/src/core/config.js

@@ -24,9 +24,12 @@ export function createWorkflowMeta({
   fileHashes = {},
   version,
   useDocker = false,
+  installation = null,
+  optionalFeatures = [],
+  optedOutFeatures = [],
 }) {
   const now = new Date().toISOString();
-  return {
+  const meta = {
     version: version || '1.0.0',
     installedAt: now,
     lastUpdated: now,
@@ -36,7 +39,13 @@ export function createWorkflowMeta({
     optionalAgents,
     useDocker,
     fileHashes,
+    optionalFeatures,
+    optedOutFeatures,
   };
+  if (installation) {
+    meta.installation = installation;
+  }
+  return meta;
 }
 
 export async function readWorkflowMeta(projectRoot) {