@e0ipso/ai-task-manager 1.36.1 → 1.38.0

package/templates/harness/skills/task-full-workflow/scripts/validate-plan-blueprint.cjs

@@ -0,0 +1,375 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/skill-scripts/validate-plan-blueprint.ts
+var validate_plan_blueprint_exports = {};
+__export(validate_plan_blueprint_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(validate_plan_blueprint_exports);
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// src/skill-scripts/shared/root.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var EXPECTED_SCHEMA = true ? 1 : 1;
+var isValidTaskManagerRoot = (taskManagerPath) => {
+  try {
+    if (!fs.existsSync(taskManagerPath)) return false;
+    if (!fs.lstatSync(taskManagerPath).isDirectory()) return false;
+    const metadataPath = path.join(taskManagerPath, ".init-metadata.json");
+    if (!fs.existsSync(metadataPath)) return false;
+    const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+    return metadata && typeof metadata === "object" && "version" in metadata;
+  } catch (_err) {
+    return false;
+  }
+};
+var getTaskManagerAt = (directory) => {
+  const taskManagerPath = path.join(directory, ".ai", "task-manager");
+  return isValidTaskManagerRoot(taskManagerPath) ? taskManagerPath : null;
+};
+var getParentPaths = (currentPath, acc = []) => {
+  const absolutePath = path.resolve(currentPath);
+  const nextAcc = [...acc, absolutePath];
+  const parentPath = path.dirname(absolutePath);
+  if (parentPath === absolutePath) return nextAcc;
+  return getParentPaths(parentPath, nextAcc);
+};
+var checkWorkspaceSchema = (metadataPath) => {
+  let metadata;
+  try {
+    metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+  } catch {
+    return;
+  }
+  const actual = typeof metadata.workspaceSchemaVersion === "number" ? metadata.workspaceSchemaVersion : 1;
+  if (actual === EXPECTED_SCHEMA) return;
+  if (actual < EXPECTED_SCHEMA) {
+    process.stderr.write(
+      `Workspace schema v${actual} is older than this skill requires (v${EXPECTED_SCHEMA}). Re-run \`npx @e0ipso/ai-task-manager init\` with the latest CLI to update.
+`
+    );
+  } else {
+    process.stderr.write(
+      `This skill (built for workspace schema v${EXPECTED_SCHEMA}) is older than the workspace (v${actual}). Re-run \`npx skills add e0ipso/ai-task-manager\` to update skills.
+`
+    );
+  }
+  process.exit(1);
+};
+var findTaskManagerRoot = (startPath = process.cwd()) => {
+  const paths = getParentPaths(startPath);
+  const found = paths.find((p) => getTaskManagerAt(p));
+  if (!found) return null;
+  const root = getTaskManagerAt(found);
+  if (root) checkWorkspaceSchema(path.join(root, ".init-metadata.json"));
+  return root;
+};
+
+// src/skill-scripts/shared/plan-scan.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/skill-scripts/shared/frontmatter.ts
+var ID_PATTERNS = [
+  /^\s*["']?id["']?\s*:\s*["']?([+-]?\d+)["']?\s*(?:#.*)?$/im,
+  /^\s*id\s*:\s*([+-]?\d+)\s*(?:#.*)?$/im,
+  /^\s*["']?id["']?\s*:\s*"([+-]?\d+)"\s*(?:#.*)?$/im,
+  /^\s*["']?id["']?\s*:\s*'([+-]?\d+)'\s*(?:#.*)?$/im,
+  /^\s*["']id["']\s*:\s*([+-]?\d+)\s*(?:#.*)?$/im,
+  /^\s*id\s*:\s*[|>]\s*([+-]?\d+)\s*$/im
+];
+var validateId = (rawId) => {
+  const id = parseInt(rawId, 10);
+  if (Number.isNaN(id) || id < 0 || id > Number.MAX_SAFE_INTEGER) return null;
+  return id;
+};
+var extractIdFromMarkdown = (content) => {
+  const frontmatterMatch = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch || !frontmatterMatch[1]) return null;
+  const block = frontmatterMatch[1];
+  for (const pattern of ID_PATTERNS) {
+    const match = block.match(pattern);
+    if (match && match[1]) {
+      const id = validateId(match[1]);
+      if (id !== null) return id;
+    }
+  }
+  return null;
+};
+var extractIdFromHtml = (content) => {
+  const headMatch = content.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+  const scope = headMatch && headMatch[1] ? headMatch[1] : content;
+  const metaPatterns = [
+    /<meta\s+[^>]*name\s*=\s*["']id["'][^>]*content\s*=\s*["']([+-]?\d+)["'][^>]*\/?>/i,
+    /<meta\s+[^>]*content\s*=\s*["']([+-]?\d+)["'][^>]*name\s*=\s*["']id["'][^>]*\/?>/i
+  ];
+  for (const pattern of metaPatterns) {
+    const match = scope.match(pattern);
+    if (match && match[1]) {
+      const id = validateId(match[1]);
+      if (id !== null) return id;
+    }
+  }
+  return null;
+};
+var extractPlanId = (content, filePath) => {
+  if (filePath.toLowerCase().endsWith(".html")) return extractIdFromHtml(content);
+  return extractIdFromMarkdown(content);
+};
+
+// src/skill-scripts/shared/plan-scan.ts
+var PLAN_EXTENSIONS = [".md", ".html"];
+var scanPlanDir = (planDirPath, dirName, isArchive) => {
+  let entries;
+  try {
+    entries = fs2.readdirSync(planDirPath, { withFileTypes: true });
+  } catch (_err) {
+    return [];
+  }
+  return entries.filter((e) => e.isFile() && PLAN_EXTENSIONS.some((ext) => e.name.endsWith(ext))).flatMap((e) => {
+    const filePath = path2.join(planDirPath, e.name);
+    try {
+      const content = fs2.readFileSync(filePath, "utf8");
+      const id = extractPlanId(content, filePath);
+      if (id === null) return [];
+      return [{ id, file: filePath, dir: planDirPath, isArchive, name: dirName }];
+    } catch (_err) {
+      return [];
+    }
+  });
+};
+var getAllPlans = (taskManagerRoot) => {
+  const sources = [
+    { dir: path2.join(taskManagerRoot, "plans"), isArchive: false },
+    { dir: path2.join(taskManagerRoot, "archive"), isArchive: true }
+  ];
+  return sources.flatMap(({ dir, isArchive }) => {
+    if (!fs2.existsSync(dir)) return [];
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch (_err) {
+      return [];
+    }
+    return entries.filter((e) => e.isDirectory()).flatMap((e) => scanPlanDir(path2.join(dir, e.name), e.name, isArchive));
+  });
+};
+
+// src/skill-scripts/shared/plan-resolve.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var isValidRootDir = (taskManagerPath) => {
+  try {
+    if (!fs3.existsSync(taskManagerPath)) return false;
+    if (!fs3.lstatSync(taskManagerPath).isDirectory()) return false;
+    const metadataPath = path3.join(taskManagerPath, ".init-metadata.json");
+    if (!fs3.existsSync(metadataPath)) return false;
+    const metadata = JSON.parse(fs3.readFileSync(metadataPath, "utf8"));
+    return metadata && typeof metadata === "object" && "version" in metadata;
+  } catch (_err) {
+    return false;
+  }
+};
+var checkStandardRootShortcut = (filePath) => {
+  const planDir = path3.dirname(filePath);
+  const parentDir = path3.dirname(planDir);
+  const possibleRoot = path3.dirname(parentDir);
+  const parentBase = path3.basename(parentDir);
+  if (parentBase !== "plans" && parentBase !== "archive") return null;
+  if (path3.basename(possibleRoot) !== "task-manager") return null;
+  const dotAiDir = path3.dirname(possibleRoot);
+  if (path3.basename(dotAiDir) !== ".ai") return null;
+  return isValidRootDir(possibleRoot) ? possibleRoot : null;
+};
+var resolveByPath = (absolutePath) => {
+  let content;
+  try {
+    content = fs3.readFileSync(absolutePath, "utf8");
+  } catch (_err) {
+    return null;
+  }
+  const planId = extractPlanId(content, absolutePath);
+  if (planId === null) return null;
+  const tmRoot = checkStandardRootShortcut(absolutePath) || findTaskManagerRoot(path3.dirname(absolutePath));
+  if (!tmRoot) return null;
+  return {
+    planFile: absolutePath,
+    planDir: path3.dirname(absolutePath),
+    taskManagerRoot: tmRoot,
+    planId
+  };
+};
+var resolveByIdInAncestry = (planId, startPath, searched = /* @__PURE__ */ new Set()) => {
+  const tmRoot = findTaskManagerRoot(startPath);
+  if (!tmRoot) return null;
+  const normalized = path3.normalize(tmRoot);
+  if (searched.has(normalized)) return null;
+  searched.add(normalized);
+  const plans = getAllPlans(tmRoot);
+  const match = plans.find((p) => p.id === planId);
+  if (match) {
+    return {
+      planFile: match.file,
+      planDir: match.dir,
+      taskManagerRoot: tmRoot,
+      planId
+    };
+  }
+  const parentOfRoot = path3.dirname(path3.dirname(tmRoot));
+  if (parentOfRoot === tmRoot) return null;
+  return resolveByIdInAncestry(planId, parentOfRoot, searched);
+};
+var resolvePlan = (input, startPath = process.cwd()) => {
+  if (input === null || input === void 0 || input === "") return null;
+  const inputStr = String(input);
+  if (inputStr.startsWith("/")) {
+    return resolveByPath(inputStr);
+  }
+  const planId = parseInt(inputStr, 10);
+  if (Number.isNaN(planId)) return null;
+  return resolveByIdInAncestry(planId, startPath);
+};
+
+// src/skill-scripts/validate-plan-blueprint.ts
+var VALID_FIELDS = [
+  "planFile",
+  "planDir",
+  "taskCount",
+  "blueprintExists",
+  "taskManagerRoot",
+  "planId"
+];
+var countTasks = (planDir) => {
+  const tasksDir = path4.join(planDir, "tasks");
+  if (!fs4.existsSync(tasksDir)) return 0;
+  try {
+    const stat = fs4.lstatSync(tasksDir);
+    if (!stat.isDirectory()) return 0;
+    return fs4.readdirSync(tasksDir).filter((f) => f.endsWith(".md")).length;
+  } catch (_err) {
+    return 0;
+  }
+};
+var checkBlueprintExists = (planFile) => {
+  try {
+    const content = fs4.readFileSync(planFile, "utf8");
+    return /^## Execution Blueprint/m.test(content);
+  } catch (_err) {
+    return false;
+  }
+};
+var usage = () => {
+  const lines = [
+    "Plan ID or absolute path is required",
+    "",
+    "Usage: node validate-plan-blueprint.cjs <plan-id-or-path> [field-name]",
+    "",
+    "Examples:",
+    "  node validate-plan-blueprint.cjs 47",
+    "  node validate-plan-blueprint.cjs /path/to/plan.md",
+    "  node validate-plan-blueprint.cjs 47 planFile",
+    "  node validate-plan-blueprint.cjs 47 blueprintExists"
+  ];
+  lines.forEach((l) => process.stderr.write(`[ERROR] ${l}
+`));
+};
+var listAvailablePlans = (startPath) => {
+  const tmRoot = findTaskManagerRoot(startPath);
+  if (!tmRoot) return [];
+  const plans = getAllPlans(tmRoot);
+  return plans.map((p) => p.name).sort((a, b) => {
+    const aMatch = a.match(/^(\d+)--/);
+    const bMatch = b.match(/^(\d+)--/);
+    if (!aMatch || !bMatch || !aMatch[1] || !bMatch[1]) return 0;
+    return parseInt(aMatch[1], 10) - parseInt(bMatch[1], 10);
+  });
+};
+var main = () => {
+  const inputId = process.argv[2];
+  const fieldName = process.argv[3];
+  if (!inputId) {
+    usage();
+    process.exit(1);
+  }
+  const numericInput = parseInt(inputId, 10);
+  const isNumeric = !Number.isNaN(numericInput);
+  const isAbsolutePath = inputId.startsWith("/");
+  if (!isNumeric && !isAbsolutePath) {
+    process.stderr.write(`[ERROR] Invalid plan ID: "${inputId}" is not a valid number
+`);
+    process.exit(1);
+  }
+  const resolved = resolvePlan(inputId);
+  if (!resolved) {
+    process.stderr.write(`[ERROR] Plan ID ${inputId} not found or invalid
+`);
+    process.stderr.write("[ERROR] \n");
+    const available = listAvailablePlans(process.cwd());
+    if (available.length > 0) {
+      process.stderr.write("[ERROR] Available plans:\n");
+      available.forEach((name) => process.stderr.write(`[ERROR]   ${name}
+`));
+    }
+    process.exit(1);
+  }
+  const result = {
+    planFile: resolved.planFile,
+    planDir: resolved.planDir,
+    taskManagerRoot: resolved.taskManagerRoot,
+    planId: resolved.planId,
+    taskCount: countTasks(resolved.planDir),
+    blueprintExists: checkBlueprintExists(resolved.planFile) ? "yes" : "no"
+  };
+  if (fieldName) {
+    if (!VALID_FIELDS.includes(fieldName)) {
+      process.stderr.write(`[ERROR] Invalid field name: ${fieldName}
+`);
+      process.stderr.write(`[ERROR] Valid fields: ${VALID_FIELDS.join(", ")}
+`);
+      process.exit(1);
+    }
+    const value = result[fieldName];
+    process.stdout.write(`${String(value)}
+`);
+  } else {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  }
+  process.exit(0);
+};
+if (require.main === module) {
+  main();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/templates/harness/skills/task-generate-tasks/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: task-generate-tasks
+description: Generate atomic Markdown tasks for an existing AI Task Manager plan in this repository. Use when the user asks to decompose a specific plan ID into tasks — discovers the local .ai/task-manager root, resolves the plan, runs the project's task-generation hooks, allocates sequential task IDs, and writes one task file per atomic unit conforming to TASK_TEMPLATE.md. Do not use for generic project planning or work outside the AI Task Manager.
+---
+
+# task-generate-tasks
+
+Drive the end-to-end decomposition of an existing AI Task Manager plan into
+atomic Markdown task files. The skill is assistant-agnostic and self-contained:
+every script it invokes lives under this skill's `scripts/` directory and is
+referenced by relative path.
+
+## Inputs
+
+The user supplies the numeric plan ID conversationally. Treat it as the only
+authoritative source of intent. Do not invent answers to clarifying questions —
+prompt the user instead.
+
+## Operating Procedure
+
+### 1. Locate the task-manager root
+
+Run `scripts/find-task-manager-root.cjs` from the user's working directory.
+The script walks up looking for `.ai/task-manager/.init-metadata.json` and
+prints the absolute path of the resolved root on success.
+
+If the script exits non-zero, the working directory is not inside an
+initialized task-manager workspace. Stop and ask the user to run the project
+initializer (e.g. `npx @e0ipso/ai-task-manager init`) before continuing. Do
+not attempt to generate tasks outside of a valid root.
+
+For every subsequent step, treat the path printed by this script as `<root>`.
+
+### 2. Resolve the plan
+
+Run `scripts/validate-plan-blueprint.cjs <plan-id> planFile` to obtain the
+absolute path of the plan file. The same script also accepts these field
+names (single-field output mode) and exposes them on demand:
+
+- `planDir` — absolute path of the plan directory
+- `taskCount` — number of existing task files in that plan's `tasks/`
+- `blueprintExists` — `yes` or `no`
+- `taskManagerRoot` — absolute path of `<root>`
+- `planId` — the resolved numeric plan ID
+
+If the script exits non-zero, stop and ask the user to confirm the plan ID.
+Do not guess a different ID.
+
+### 3. Load project context
+
+Read these files, in order:
+
+- `<root>/config/TASK_MANAGER.md` — directory conventions for plans, tasks,
+  and the archive layout.
+- The plan body at the path returned by step 2 — this is the contract for
+  what tasks must exist.
+- `<root>/config/templates/TASK_TEMPLATE.md` — every task file you emit must
+  conform to this template's frontmatter schema and section structure.
+
+### 4. Analyze and decompose the plan
+
+Read the entire plan. Identify all concrete deliverables **explicitly stated**.
+Decompose each deliverable into atomic tasks only when genuinely needed.
+
+**Task minimization (mandatory):**
+
+- Create only the minimum number of tasks necessary. Target a 20–30%
+  reduction from comprehensive lists by questioning the necessity of each
+  candidate.
+- **Direct Implementation Only**: a task corresponds to an explicit
+  requirement, not a "nice-to-have".
+- **DRY Task Principle**: each task has a unique, non-overlapping purpose.
+- **Question Everything**: for each task, ask "Is this absolutely necessary
+  to meet the plan objectives?"
+- **Avoid Gold-plating**: resist comprehensive features the plan does not
+  require.
+
+**Antipatterns to avoid:**
+
+- Separating "error handling" from the main implementation when it can be
+  inline.
+- Splitting trivially small operations into multiple tasks (e.g. "validate
+  input" + "process input" as separate units).
+- Adding tasks for "future extensibility" or "best practices" the plan does
+  not mention.
+- Comprehensive test suites for trivial functionality.
+
+### 5. Apply granularity and skill rules
+
+Each task must be:
+
+- **Single-purpose** — one clear deliverable.
+- **Atomic** — cannot be meaningfully split further.
+- **Skill-specific** — executable by an agent with 1–2 technical skills.
+- **Verifiable** — has explicit acceptance criteria.
+
+Skill assignment (kebab-case, automatically inferred from the task's
+technical requirements):
+
+- 1 skill — single-domain task (e.g. `["css"]`, `["jest"]`).
+- 2 skills — complementary domains (e.g. `["api-endpoints", "database"]`,
+  `["react-components", "jest"]`).
+- 3+ skills indicates the task should be broken down further.
+
+### 6. Test philosophy: "write a few tests, mostly integration"
+
+When generating test tasks, keep this constraint:
+
+**Definition.** Meaningful tests verify custom business logic, critical paths,
+and edge cases specific to this application. Test *your* code, not the
+framework or library.
+
+**When TO write tests:**
+
+- Custom business logic and algorithms.
+- Critical user workflows and data transformations.
+- Edge cases and error conditions for core functionality.
+- Integration points between components.
+- Complex validation logic or calculations.
+
+**When NOT to write tests:**
+
+- Third-party library functionality.
+- Framework features.
+- Simple CRUD operations without custom logic.
+- Trivial getters/setters or static configuration.
+- Obvious functionality that would break immediately if incorrect.
+
+**Test task creation rules:**
+
+- Combine related test scenarios into a single task (e.g. "Test user
+  authentication flow" not separate tasks for login, logout, validation).
+- Favor integration and critical-path coverage over per-method unit tests.
+- Avoid one test task per CRUD operation.
+- Question whether simple functions need a dedicated test task.
+
+If any test task is generated, restate this section verbatim or near-verbatim
+in that task's "Implementation Notes" so the executing agent applies it.
+
+### 7. Dependency analysis
+
+For each task, identify:
+
+- **Hard dependencies**: tasks that MUST complete before this one can start.
+- **Soft dependencies**: tasks that SHOULD complete for optimal execution.
+
+A task B depends on A if B requires A's output or artifacts, modifies code
+created by A, or tests functionality implemented by A. Validate that the
+final dependency graph is acyclic.
+
+### 8. Allocate task IDs
+
+Run `scripts/get-next-task-id.cjs <plan-id>` to obtain the first available
+task ID. Allocate subsequent IDs by incrementing in-process; do not invoke
+the script repeatedly. Use the unpadded integer in the task frontmatter `id`
+field and the zero-padded form (`{padded-id}--{slug}`) for the filename.
+
+The slug derives from a short task title: lowercase, alphanumeric and
+hyphens only, collapsed, trimmed.
+
+### 9. Emit the task files
+
+Write each task to:
+
+```
+<root>/plans/<plan-dir-name>/tasks/{padded-id}--{slug}.md
+```
+
+Each file must conform to `<root>/config/templates/TASK_TEMPLATE.md`,
+including required frontmatter fields:
+
+- `id` (integer)
+- `group` (string)
+- `dependencies` (array of task IDs, possibly empty)
+- `status` — `pending` for new tasks
+- `created` (YYYY-MM-DD)
+- `skills` (array of 1–2 kebab-case skills)
+
+Optional frontmatter for high-complexity or decomposed tasks:
+
+- `complexity_score` (number, 1–10, include only if >4 or for decomposed
+  tasks)
+- `complexity_notes` (string)
+
+The body sections (Objective, Skills Required, Acceptance Criteria, Technical
+Requirements, Input Dependencies, Output Artifacts, Implementation Notes)
+must be filled with task-specific content. Place detailed implementation
+guidance inside a `<details>` block under "Implementation Notes" — write it
+so a non-thinking LLM could execute the task from that section alone.
+
+### 10. Validation checklist
+
+Before declaring task generation complete, verify:
+
+- Each task has 1–2 appropriate technical skills assigned and inferred from
+  its objectives.
+- Dependencies form an acyclic graph; no orphan or circular references.
+- Task IDs are unique, sequential, and start from the value returned by
+  `get-next-task-id.cjs`.
+- Groups are consistent and meaningful.
+- Every **explicitly stated** deliverable in the plan is covered.
+- No redundant or overlapping tasks.
+- Minimization applied (20–30% reduction target).
+- Test tasks focus on business logic, not framework functionality.
+- No gold-plating: only plan requirements are addressed.
+
+### 11. Run the POST_TASK_GENERATION_ALL hook
+
+Read `<root>/config/hooks/POST_TASK_GENERATION_ALL.md` and follow its
+instructions. This typically requires:
+
+- Sanity-checking complexity (3+ technologies/skills → split; vague criteria
+  → sharpen; trivially small → merge).
+- Appending an Execution Blueprint section to the plan document, including a
+  Mermaid dependency diagram and explicit phase groupings (Phase 1 contains
+  zero-dependency tasks; each subsequent phase contains tasks whose
+  dependencies all live in earlier phases). Use
+  `<root>/config/templates/BLUEPRINT_TEMPLATE.md` for structure.
+
+### 12. Emit the structured summary
+
+Conclude with exactly this block as the final output:
+
+```
+---
+Task Generation Summary:
+- Plan ID: [numeric-id]
+- Tasks: [count]
+- Status: Ready for execution
+```
+
+The summary is consumed by downstream automation; keep the format exact.
+
+## Failure Modes
+
+- **No task-manager root found.** Stop, instruct the user to initialize the
+  project. Do not write any files.
+- **Plan ID does not resolve.** Stop and surface the script's stderr to the
+  user. Do not guess a different ID and do not write any files.
+- **User declines to clarify a blocking ambiguity.** Mark the affected tasks
+  with `status: "needs-clarification"` and document the open question in the
+  task's "Implementation Notes". Do not invent answers.
+- **A helper script fails unexpectedly.** Surface stderr to the user and
+  stop — do not fall back to manual ID allocation or path discovery.