agileflow 4.0.0-alpha.2 → 4.0.0-alpha.21

package/content/plugins/core/hooks/damage-control-bash.js

@@ -49,8 +49,16 @@ async function main() {
   try {
     const parsed = yaml.load(fs.readFileSync(patternsPath, "utf8"));
     patterns = Array.isArray(parsed && parsed.patterns) ? parsed.patterns : [];
-  } catch {
-    process.exit(0); // No patterns file, fail open.
+  } catch (err) {
+    // Fail open, but warn loudly: a missing/unreadable patterns file
+    // means every dangerous command will go through unblocked, and
+    // the user MUST notice. Repeated warnings on every Bash call are
+    // intentional — they signal "damageControl is broken, fix it or
+    // disable the preset in agileflow.config.json".
+    process.stderr.write(
+      `agileflow damage-control: WARNING — patterns file unreadable (${err.code || err.name}: ${patternsPath}). Bash safety guards are DISABLED until this is fixed.\n`,
+    );
+    process.exit(0);
   }
 
   for (const p of patterns) {

package/content/plugins/core/hooks/damage-control-edit.js

@@ -46,7 +46,10 @@ async function main() {
   try {
     const parsed = yaml.load(fs.readFileSync(patternsPath, "utf8"));
     patterns = Array.isArray(parsed && parsed.patterns) ? parsed.patterns : [];
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `agileflow damage-control: WARNING — patterns file unreadable (${err.code || err.name}: ${patternsPath}). Edit safety guards are DISABLED until this is fixed.\n`,
+    );
     process.exit(0);
   }
 

package/content/plugins/core/hooks/damage-control-patterns.yaml

@@ -15,7 +15,7 @@
 
 patterns:
   # --- Catastrophic filesystem operations ---
-  - regex: 'rm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+(/|~|\$HOME)\b'
+  - regex: 'rm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+(/|~|\$HOME)(\s|$)'
     kind: bash
     severity: error
     reason: rm -rf on / or $HOME is almost certainly a mistake — refuse outright

package/content/plugins/core/hooks/damage-control-write.js

@@ -42,7 +42,10 @@ async function main() {
   try {
     const parsed = yaml.load(fs.readFileSync(patternsPath, "utf8"));
     patterns = Array.isArray(parsed && parsed.patterns) ? parsed.patterns : [];
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `agileflow damage-control: WARNING — patterns file unreadable (${err.code || err.name}: ${patternsPath}). Write safety guards are DISABLED until this is fixed.\n`,
+    );
     process.exit(0);
   }
 

package/content/plugins/core/hooks/{pre-compact-state.js → post-compact-state.js}

@@ -1,16 +1,15 @@
 #!/usr/bin/env node
 /**
- * Core hook: pre-compact-state (PreCompact).
+ * Core hook: post-compact-state (PostCompact).
  *
- * Captures the state Claude needs to know AFTER the compaction summary
- * replaces most of the conversation: the active story, the active
- * command, recent decisions, and the dirty git state. Without this,
- * compaction often loses thread on multi-turn implementation work.
+ * Re-injects the state Claude needs after compaction replaces most of
+ * the conversation: active story, active command, git state, and user
+ * preferences. Without this, compaction loses thread on multi-turn work.
  *
  * Output is plain markdown printed to stdout — Claude Code includes
- * the hook's stdout in the prompt context after compaction.
+ * the hook's stdout in the fresh context after compaction.
  *
- * Exits 0 always (must not block compaction).
+ * Exits 0 always (must not block).
  */
 const fs = require("fs");
 const path = require("path");
@@ -38,12 +37,27 @@ function git(args) {
   }
 }
 
+const { buildPreferencesBlock } = require("./preferences-injector.js");
+
 const out = [];
+
+const prefsBlock = buildPreferencesBlock();
+if (prefsBlock) {
+  out.push(prefsBlock);
+  out.push("");
+}
+
 out.push("## Pre-compaction state preservation");
 out.push("");
 
 const status = readJSON(path.join(projectDir, "docs/09-agents/status.json"));
-if (status && status.stories) {
+if (!status) {
+  // Fresh project — no story tracker yet. Say so explicitly so the
+  // post-compaction prompt knows the section was reached, not silently
+  // skipped due to an error.
+  out.push("Active stories: (none yet — docs/09-agents/status.json not found)");
+  out.push("");
+} else if (status.stories) {
   const inProgress = Object.entries(status.stories)
     .filter(([, s]) => s && s.status === "in_progress")
     .map(([id, s]) => `${id} ${s.title || ""}`);
@@ -51,6 +65,9 @@ if (status && status.stories) {
     out.push("Active stories:");
     for (const s of inProgress) out.push(`  - ${s}`);
     out.push("");
+  } else {
+    out.push("Active stories: (none in progress)");
+    out.push("");
   }
 }
 

package/content/plugins/core/hooks/preferences-injector.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+/**
+ * Core hook: preferences-injector (SessionStart).
+ *
+ * Reads agileflow.config.json and emits a concise user-preferences block
+ * so every skill and interaction in the session automatically respects
+ * the user's configured settings — without each skill needing its own
+ * config-reading logic.
+ *
+ * Always exits 0.
+ */
+const path = require("path");
+const fs = require("fs");
+
+const projectDir =
+  process.env.AGILEFLOW_PROJECT_DIR ||
+  process.env.CLAUDE_PROJECT_DIR ||
+  process.cwd();
+
+// Resolve capabilities.js from the installed runtime or the source tree.
+let IDE_CAPABILITIES = null;
+try {
+  ({ IDE_CAPABILITIES } = require("../../../src/runtime/ide/capabilities.js"));
+} catch {
+  try {
+    // Installed path: node_modules/agileflow/src/runtime/ide/capabilities.js
+    ({
+      IDE_CAPABILITIES,
+    } = require("agileflow/src/runtime/ide/capabilities.js"));
+  } catch {
+    // capabilities unavailable — skip capability block
+  }
+}
+
+// Resolve learnings helpers from the installed runtime or the source tree.
+let _readLearnings = null;
+let _formatLearningsBlock = null;
+try {
+  const learnings = require("../../../src/runtime/skills/learnings.js");
+  _readLearnings = learnings.readLearnings;
+  _formatLearningsBlock = learnings.formatLearningsBlock;
+} catch {
+  try {
+    const learnings = require("agileflow/src/runtime/skills/learnings.js");
+    _readLearnings = learnings.readLearnings;
+    _formatLearningsBlock = learnings.formatLearningsBlock;
+  } catch {
+    // learnings unavailable — skip learnings block
+  }
+}
+
+module.exports = { buildPreferencesBlock, buildLearningsBlock };
+
+function buildCapabilitiesBlock(cfg) {
+  if (!IDE_CAPABILITIES) return null;
+
+  const targets = cfg?.ide?.targets;
+  if (!Array.isArray(targets) || targets.length === 0) return null;
+
+  // Use the first target as the primary IDE for capability detection.
+  const primaryIde = targets[0];
+  const caps = IDE_CAPABILITIES[primaryIde];
+  if (!caps) return null;
+
+  const tick = (v) => (v ? "✓" : "✗");
+
+  const lines = [
+    `## Runtime Capabilities (${caps.description})`,
+    "",
+    "Skills and workflows adapt their behavior based on what this IDE supports:",
+    "",
+    `| Capability | Available | Behavior when unavailable |`,
+    `|------------|-----------|--------------------------|`,
+    `| **Interactive prompts** (AskUserQuestion) | ${tick(caps.interactivePrompts)} | Present options as a numbered list instead |`,
+    `| **Agent spawning** (Task / multi-agent) | ${tick(caps.multiAgent)} | Work through each analysis inline, sequentially |`,
+    `| **Session restore** (PostCompact hook) | ${tick(caps.sessionRestore)} | Re-state context manually if conversation compacts |`,
+    `| **Lifecycle hooks** | ${tick(caps.hooks)} | Guidance and state injection unavailable between sessions |`,
+    "",
+  ];
+
+  if (!caps.interactivePrompts) {
+    lines.push(
+      "**Note:** This IDE does not support interactive prompts. When a workflow says to present options, write a numbered list and ask the user to reply with a number.",
+    );
+  }
+  if (!caps.multiAgent) {
+    lines.push(
+      "**Note:** This IDE does not support agent spawning. When a workflow calls for running multiple expert agents in parallel, perform each analysis inline and sequentially instead.",
+    );
+  }
+
+  // Filter trailing empty string if no notes added
+  return lines.join("\n").trimEnd();
+}
+
+function buildPreferencesBlock() {
+  let cfg = {};
+  try {
+    const raw = fs.readFileSync(
+      path.join(projectDir, "agileflow.config.json"),
+      "utf8",
+    );
+    cfg = JSON.parse(raw);
+  } catch {
+    // config missing — emit nothing
+    return null;
+  }
+
+  const babysit = cfg?.plugins?.core?.settings?.babysit;
+  if (!babysit) return null;
+
+  const mode = babysit.mode || "full";
+  const f = babysit.features || {};
+
+  const on = (key) => {
+    if (mode === "full") return true;
+    if (mode === "light")
+      return ["askQuestions", "planMode", "taskTracking"].includes(key);
+    if (mode === "minimal") return key === "askQuestions";
+    // custom — default true for core features unless explicitly false
+    const defaults = {
+      askQuestions: true,
+      planMode: true,
+      delegation: true,
+      taskTracking: true,
+      progressUpdates: true,
+      auditAll: false,
+      logicAudit: true,
+      flowAudit: true,
+      securityAudit: true,
+      performanceAudit: false,
+      accessibilityAudit: false,
+      legalAudit: false,
+      strictMode: false,
+      tddMode: false,
+    };
+    return key in f ? f[key] : (defaults[key] ?? false);
+  };
+
+  const prefs = [];
+
+  if (on("askQuestions")) {
+    prefs.push(
+      '- **Ask at decision points** — end responses with AskUserQuestion (specific options, one marked Recommended). Never generic "Continue?".',
+    );
+  }
+  if (on("planMode")) {
+    prefs.push(
+      "- **Plan mode for non-trivial work** — EnterPlanMode before implementing anything beyond a one-liner.",
+    );
+  }
+  if (on("delegation")) {
+    prefs.push(
+      "- **Delegate to domain experts** — use Task tool with appropriate subagent_type for complex single-domain work; orchestrator for multi-domain.",
+    );
+  }
+  if (on("taskTracking")) {
+    prefs.push(
+      "- **Track progress** — TaskCreate for 3+ step tasks, TaskUpdate as each completes.",
+    );
+  }
+  if (on("progressUpdates")) {
+    prefs.push(
+      "- **Short status updates** — brief progress notes while working.",
+    );
+  }
+  const always = mode === "full" || on("auditAll");
+
+  if (on("logicAudit")) {
+    prefs.push(
+      always
+        ? "- **Logic audit after every implementation** — suggest 🔍 Run logic audit as (Recommended) after every implementation."
+        : "- **Logic audit after implementation** — suggest 🔍 Run logic audit as (Recommended) after implementation.",
+    );
+  }
+  if (on("flowAudit")) {
+    prefs.push(
+      always
+        ? "- **Flow audit after every implementation** — suggest 🔄 Run flow audit after every implementation. Include a Verify flow integrity step in plans."
+        : "- **Flow audit after implementation** — when user-facing flows were touched (forms, navigation, auth, CRUD), suggest 🔄 Run flow audit after implementation. Include a Verify flow integrity step in plans.",
+    );
+  }
+  if (on("securityAudit")) {
+    prefs.push(
+      always
+        ? "- **Security audit after every implementation** — suggest 🔒 Run security audit after every implementation."
+        : "- **Security audit after implementation** — when auth, APIs, user input, file handling, or sensitive data were touched, suggest 🔒 Run security audit after implementation.",
+    );
+  }
+  if (on("performanceAudit")) {
+    prefs.push(
+      always
+        ? "- **Performance audit after every implementation** — suggest ⚡ Run performance audit after every implementation."
+        : "- **Performance audit after implementation** — when database queries, rendering, large data, or caching were touched, suggest ⚡ Run performance audit after implementation.",
+    );
+  }
+  if (on("accessibilityAudit")) {
+    prefs.push(
+      always
+        ? "- **Accessibility audit after every implementation** — suggest ♿ Run accessibility audit after every implementation."
+        : "- **Accessibility audit after implementation** — when UI components, forms, or interactive elements were changed, suggest ♿ Run accessibility audit after implementation.",
+    );
+  }
+  if (on("legalAudit")) {
+    prefs.push(
+      always
+        ? "- **Legal audit after every implementation** — suggest ⚖️ Run legal audit after every implementation."
+        : "- **Legal audit after implementation** — when data collection, privacy, user consent, or compliance-sensitive code was touched, suggest ⚖️ Run legal audit after implementation.",
+    );
+  }
+  if (on("strictMode")) {
+    prefs.push(
+      "- **Strict gates** — hide commit option until tests pass; auto-trigger code review at 5+ files changed; remove skip options.",
+    );
+  }
+  if (on("tddMode")) {
+    prefs.push(
+      "- **TDD phases** — RED (failing tests first) → GREEN (minimum code) → REFACTOR. Gate each phase.",
+    );
+  }
+
+  if (prefs.length === 0) return null;
+
+  const modeLabel =
+    mode === "custom"
+      ? `custom (${Object.entries(f)
+          .filter(([, v]) => v)
+          .map(([k]) => k)
+          .join(", ")})`
+      : mode;
+
+  const prefsBlock = [
+    `## User Preferences (agileflow ${modeLabel} mode)`,
+    "",
+    "Apply these preferences throughout this session across all skills and tasks:",
+    "",
+    ...prefs,
+    "",
+    "To change: run `agileflow setup`.",
+  ].join("\n");
+
+  const capsBlock = buildCapabilitiesBlock(cfg);
+
+  return capsBlock ? `${capsBlock}\n\n${prefsBlock}` : prefsBlock;
+}
+
+/**
+ * Build a learnings block by scanning the installed skills directory for
+ * skills that have `learns.enabled: true` and have at least one learning entry.
+ *
+ * @param {object} cfg - parsed agileflow.config.json
+ * @returns {string|null}
+ */
+function buildLearningsBlock(cfg) {
+  if (!_readLearnings || !_formatLearningsBlock) return null;
+  if (!cfg?.learnings?.enabled) return null;
+
+  const primaryIde =
+    Array.isArray(cfg?.ide?.targets) && cfg.ide.targets.length > 0
+      ? cfg.ide.targets[0]
+      : "claude-code";
+
+  const skillsDir =
+    IDE_CAPABILITIES?.[primaryIde]?.skillsDir ?? ".claude/skills";
+  const absoluteSkillsDir = path.join(projectDir, skillsDir);
+
+  let skillNames;
+  try {
+    skillNames = fs.readdirSync(absoluteSkillsDir);
+  } catch {
+    return null; // skills dir not yet installed
+  }
+
+  const yaml = (() => {
+    try {
+      return require("js-yaml");
+    } catch {
+      return null;
+    }
+  })();
+  if (!yaml) return null;
+
+  const blocks = [];
+
+  for (const skillName of skillNames) {
+    const skillMdPath = path.join(absoluteSkillsDir, skillName, "SKILL.md");
+    let skillMdText;
+    try {
+      skillMdText = fs.readFileSync(skillMdPath, "utf8");
+    } catch {
+      continue;
+    }
+
+    // Parse frontmatter between first two `---` fences.
+    const fmMatch = skillMdText.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fmMatch) continue;
+
+    let fm;
+    try {
+      fm = yaml.load(fmMatch[1]);
+    } catch {
+      continue;
+    }
+
+    if (!fm?.learns?.enabled) continue;
+
+    // readLearnings is async — run synchronously via the already-read skills dir.
+    // We resolve the learnings file path directly.
+    const learnFile = fm.learns.file || `_learnings/${skillName}.yaml`;
+    const safeParts = learnFile
+      .split("/")
+      .filter((p) => p && p !== ".." && p !== ".");
+    const learnFilePath = path.join(absoluteSkillsDir, skillName, ...safeParts);
+
+    let learningsData;
+    try {
+      const text = fs.readFileSync(learnFilePath, "utf8");
+      if (!text.trim()) continue;
+      const doc = yaml.load(text);
+      if (!doc || !Array.isArray(doc.entries) || doc.entries.length === 0)
+        continue;
+      learningsData = { entries: doc.entries, skill: skillName };
+    } catch {
+      continue; // file absent or invalid — skip silently
+    }
+
+    const block = _formatLearningsBlock(learningsData);
+    if (block) blocks.push(block);
+  }
+
+  return blocks.length > 0 ? blocks.join("\n\n") : null;
+}
+
+if (require.main === module) {
+  let cfg = {};
+  try {
+    cfg = JSON.parse(
+      fs.readFileSync(path.join(projectDir, "agileflow.config.json"), "utf8"),
+    );
+  } catch {
+    /* ignore */
+  }
+
+  const prefsBlock = buildPreferencesBlock();
+  const learnBlock = buildLearningsBlock(cfg);
+
+  const parts = [prefsBlock, learnBlock].filter(Boolean);
+  if (parts.length > 0) {
+    process.stdout.write(parts.join("\n\n") + "\n");
+  }
+  process.exit(0);
+}

package/content/plugins/core/plugin.yaml

@@ -1,13 +1,6 @@
-# Core plugin — essential AgileFlow workflow.
-# Always enabled; cannot be disabled.
-#
-# Hooks declared here are CANDIDATES — the install-time aggregator
-# filters them by the user's `behaviors:` map in agileflow.config.json.
-# A hook ID that maps to a disabled behavior never enters the
-# generated hook-manifest.yaml. See apps/cli/src/runtime/hooks/aggregator.js.
 id: core
 name: Core
-description: Epic, Story, Status, Babysit — essential agile workflow.
+description: Essential AgileFlow skills.
 version: 1.0.0
 enabledByDefault: true
 cannotDisable: true
@@ -15,7 +8,6 @@ cannotDisable: true
 depends: []
 
 provides:
-  commands: []
   skills:
     - id: agileflow-adr
       dir: skills/agileflow-adr
@@ -27,56 +19,60 @@ provides:
       dir: skills/agileflow-status-updater
     - id: agileflow-babysit-mentor
       dir: skills/agileflow-babysit-mentor
-  agents: []
+  agents:
+    - id: adr-writer
+      path: agents/adr-writer.md
+    - id: epic-planner
+      path: agents/epic-planner.md
+    - id: mentor
+      path: agents/mentor.md
+    - id: orchestrator
+      path: agents/orchestrator.md
+    - id: team-coordinator
+      path: agents/team-coordinator.md
+    - id: team-lead
+      path: agents/team-lead.md
+    - id: workspace-orchestrator
+      path: agents/workspace-orchestrator.md
   hooks:
-    # SessionStart — context loading + (optional) mentor injection.
     - id: context-loader
       event: SessionStart
       script: hooks/context-loader.js
       timeout: 5000
       skipOnError: true
       behavior: loadContext
-
-    - id: babysit-mentor-injector
+    - id: preferences-injector
       event: SessionStart
-      script: hooks/babysit-mentor-injector.js
+      script: hooks/preferences-injector.js
       timeout: 2000
       skipOnError: true
       runAfter: [context-loader]
       behavior: babysitDefault
-
-    # PreToolUse — damage control. skipOnError false: errors should
-    # block dangerous operations rather than be tolerated.
     - id: damage-control-bash
       event: PreToolUse
       matcher: Bash
       script: hooks/damage-control-bash.js
       timeout: 3000
       skipOnError: false
-      behavior: damageControl
-
+      behavior: damageControlBash
     - id: damage-control-edit
       event: PreToolUse
       matcher: Edit
       script: hooks/damage-control-edit.js
       timeout: 3000
       skipOnError: false
-      behavior: damageControl
-
+      behavior: damageControlEdit
     - id: damage-control-write
       event: PreToolUse
       matcher: Write
       script: hooks/damage-control-write.js
       timeout: 3000
       skipOnError: false
-      behavior: damageControl
-
-    # PreCompact — preserve state across compaction.
-    - id: pre-compact-state
-      event: PreCompact
-      script: hooks/pre-compact-state.js
+      behavior: damageControlWrite
+    - id: post-compact-state
+      event: PostCompact
+      script: hooks/post-compact-state.js
       timeout: 5000
       skipOnError: true
       behavior: preCompactState
-
   templates: []

package/content/plugins/core/skills/agileflow-adr/SKILL.md

@@ -34,8 +34,6 @@ depends:
   plugins: [core]
 ---
 
-<!-- {{PERSONALIZATION_BLOCK}} -->
-
 # AgileFlow ADR Writer
 
 Captures architectural / technical decisions as formal Architecture
@@ -66,6 +64,7 @@ and link the chain.
 ## Self-improving learnings
 
 `.agileflow/skills/_learnings/adr.yaml` records preferences:
+
 - Default `Status:` value (Proposed vs Accepted)
 - Whether to require all four MADR sections or allow brief mode
 - Preferred date format
@@ -82,14 +81,17 @@ and link the chain.
 **Tags**: architecture, database, api, …
 
 ## Context and Problem Statement
+
 [Describe the context and problem. What are we trying to solve? Why now?]
 
 ## Decision Drivers
+
 - [e.g., Performance requirements]
 - [e.g., Team expertise]
 - [e.g., Cost constraints]
 
 ## Considered Options
+
 - [Option 1]
 - [Option 2]
 - [Option 3]
@@ -101,24 +103,29 @@ and link the chain.
 **Justification**: [Why this option best satisfies the drivers]
 
 ### Positive Consequences
+
 - [Good outcome 1]
 - [Good outcome 2]
 
 ### Negative Consequences
+
 - [Bad outcome 1] — Mitigation: [plan, if any]
 - [Bad outcome 2]
 
 ## Pros and Cons of the Options
 
 ### [Option 1]
+
 **Pros**: …
 **Cons**: …
 
 ### [Option 2]
+
 **Pros**: …
 **Cons**: …
 
 ## Links
+
 - [Related ADRs]
 - [Relevant documentation]
 - [External resources]
@@ -134,10 +141,12 @@ and link the chain.
 ## When to write the ADR vs ask first
 
 Write it now (with `Status: Accepted`):
+
 - The user has already made a clear decision and wants to record it
 - The user explicitly asks for the ADR
 
 Ask first (then write with `Status: Proposed` or `Accepted`):
+
 - Multiple options are still in play
 - Drivers / constraints aren't clear yet
 - The chosen option's justification is one-line ("we like it more")
@@ -157,12 +166,13 @@ Ask first (then write with `Status: Proposed` or `Accepted`):
 
 ## Integration
 
-- **agileflow-story-writer** — completed ADRs inform Technical Notes
-  in stories
-- **agileflow-epic-planner** — major epics often spawn one or more
-  ADRs at planning time
-- **agileflow-status-updater** — flipping an ADR from Proposed to
-  Accepted is a status mutation through that skill
+- **agileflow-story-writer** — completed ADRs inform Technical Notes in stories; reference the ADR number in the story's context section
+- **agileflow-epic-planner** — major epics often spawn one or more ADRs at planning time; create the ADR before writing stories so implementation decisions are settled
+- **agileflow-status-updater** — flipping an ADR from Proposed to Accepted is a status mutation; route through status-updater to keep `status.json` accurate
+- **agileflow-council** — council sessions are the primary source of ADR content; after a council reaches a decision, create an ADR to record it formally
+- **agileflow-research** — research provides the factual foundation for ADRs (benchmarks, library comparisons, community precedent); always link or summarise the research in the ADR body
+- **agileflow-planning** — use planning's impact analysis output as the context section of an ADR when the decision involves scope or delivery trade-offs
+- **agileflow-delivery** — for breaking API changes or major dependency upgrades, create an ADR before the delivery cycle begins so the rationale is documented before merge
 
 ## Notes
 
@@ -177,3 +187,19 @@ Ask first (then write with `Status: Proposed` or `Accepted`):
   knowing who to ask.
 - Date the ADR — context erodes; the date is the timestamp on the
   thinking, not just the file.
+
+## References
+
+Load these files when you need deeper context for the relevant task:
+
+| File                              | When to load                                                                                         |
+| --------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| `references/madr-format-guide.md` | Writing or reviewing an ADR — MADR format, required sections, common mistakes, numbering conventions |
+
+## Workflows
+
+Follow these step-by-step when the user initiates the matching action:
+
+| File                     | When to follow                                                                                                        |
+| ------------------------ | --------------------------------------------------------------------------------------------------------------------- |
+| `workflows/write-adr.md` | User wants to record a decision or is comparing options — gathers context, drafts ADR, gets confirmation, writes file |