npm - @e0ipso/ai-task-manager - Versions diffs - 1.36.1 → 1.37.0 - Mend

@e0ipso/ai-task-manager 1.36.1 → 1.37.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/templates/harness/skills/task-create-plan/SKILL.md ADDED Viewed

@@ -0,0 +1,120 @@
+---
+name: task-create-plan
+description: Create a new AI Task Manager plan for this repository. Use when the user asks to draft, plan, or scope a new task-manager plan — discovers the local .ai/task-manager root, runs the project's plan hooks, gathers clarifications, allocates the next plan ID, and writes a semantic HTML plan conforming to PLAN_TEMPLATE.html. Do not use for generic brainstorming or work outside the AI Task Manager.
+---
+# task-create-plan
+Drive the end-to-end creation of a new AI Task Manager plan for the user's
+repository. 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's request supplies the work order. 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 create a plan outside of a valid root.
+For every subsequent step, treat the path printed by this script as `<root>`.
+### 2. Load project context
+Read `<root>/config/TASK_MANAGER.md` for the directory structure conventions
+this project uses. Read `<root>/config/hooks/PRE_PLAN.md` and execute the
+instructions it contains before proceeding. Read
+`<root>/config/templates/PLAN_TEMPLATE.html` so the plan you emit conforms
+to its semantic structure.
+### 3. Analyze the work order
+Identify:
+- Objective and end goal.
+- Scope and explicit boundaries.
+- Success criteria.
+- Dependencies, prerequisites, blockers.
+- Technical requirements and constraints.
+### 4. Clarification loop
+If any critical context is missing, ask the user targeted questions. Keep
+looping until you have no further questions. Explicitly confirm whether
+backwards compatibility is required. Never invent answers; never paper over
+a missing answer.
+If the user declines to clarify a blocking question, stop and report the
+plan as needing clarification. Do not produce a partial plan.
+### 5. Allocate the next plan ID
+Run `scripts/get-next-plan-id.cjs` to obtain the next available plan ID.
+Pass `<root>` as the first argument when invoking the script from a working
+directory that is not inside the project, otherwise no argument is required.
+The script prints a single integer.
+Compute the zero-padded form for directory naming (`{padded-id}--{slug}`)
+and use the unpadded integer in the plan frontmatter and the final summary.
+### 6. Emit the plan
+Write the plan to:
+```
+<root>/plans/{padded-id}--{slug}/plan-{padded-id}--{slug}.html
+```
+The output must:
+- Conform to `<root>/config/templates/PLAN_TEMPLATE.html`, including required
+  `<meta>` elements (at minimum `id`, `summary`, `created`) inside `<head>`.
+- Contain the standard sections from the template body.
+- Use semantic HTML, not free-form prose.
+- Avoid time estimates, task lists, or code samples — those belong to the
+  later task-generation phase.
+The `<slug>` is derived from the plan summary: lowercase, alphanumeric and
+hyphens only, collapsed, trimmed.
+### 7. Run post-plan hook
+Execute `<root>/config/hooks/POST_PLAN.md` after the plan file is written.
+### 8. Emit the structured summary
+Conclude with exactly this block as the final output:
+```
+---
+Plan Summary:
+- Plan ID: [numeric-id]
+- Plan File: [absolute-path-to-plan-file]
+```
+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.
+- **User refuses to answer a clarifying question that blocks planning.**
+  Report `needs-clarification` and stop. Do not produce a plan.
+- **Plan ID script fails.** Re-check the resolved root and re-run. If it
+  continues to fail, surface stderr to the user and stop — do not guess an ID.
+- **Plan directory already exists for the allocated ID.** Re-run the
+  next-plan-id script (a concurrent run may have advanced it) and retry once.
+  If the conflict persists, stop and report.

package/templates/harness/skills/task-create-plan/scripts/find-task-manager-root.cjs ADDED Viewed

@@ -0,0 +1,116 @@
+"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/find-task-manager-root.ts
+var find_task_manager_root_exports = {};
+__export(find_task_manager_root_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(find_task_manager_root_exports);
+// 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/find-task-manager-root.ts
+var main = () => {
+  const startPath = process.argv[2] || process.cwd();
+  const root = findTaskManagerRoot(startPath);
+  if (!root) {
+    process.stderr.write(
+      `Could not find .ai/task-manager root from ${startPath} or any parent directory.
+`
+    );
+    process.exit(1);
+  }
+  process.stdout.write(`${root}
+`);
+  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-create-plan/scripts/get-next-plan-id.cjs ADDED Viewed

@@ -0,0 +1,214 @@
+"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/get-next-plan-id.ts
+var get_next_plan_id_exports = {};
+__export(get_next_plan_id_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(get_next_plan_id_exports);
+// 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));
+  });
+};
+var computeNextPlanId = (taskManagerRoot) => {
+  const plans = getAllPlans(taskManagerRoot);
+  return plans.reduce((max, p) => Math.max(max, p.id), 0) + 1;
+};
+// src/skill-scripts/get-next-plan-id.ts
+var main = () => {
+  const rootArg = process.argv[2];
+  let root;
+  if (rootArg) {
+    root = rootArg;
+  } else {
+    root = findTaskManagerRoot(process.cwd());
+  }
+  if (!root) {
+    process.stderr.write(
+      "No .ai/task-manager root found. Run this from inside an initialized task-manager workspace.\n"
+    );
+    process.exit(1);
+  }
+  process.stdout.write(`${computeNextPlanId(root)}
+`);
+  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-execute-blueprint/SKILL.md ADDED Viewed

@@ -0,0 +1,139 @@
+---
+name: task-execute-blueprint
+description: Execute an AI Task Manager plan blueprint for this repository. Use when the user asks to run, implement, or carry out a specific plan ID — discovers the local .ai/task-manager root, resolves the plan, validates or auto-generates tasks and the execution blueprint, optionally creates a feature branch, runs phases with lifecycle hooks, enforces validation gates, appends an execution summary, and archives the completed plan. Do not use for generic development work outside the AI Task Manager.
+---
+# task-execute-blueprint
+Drive the end-to-end execution of an existing AI Task Manager plan blueprint. 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.
+## Critical Rules
+1. **Never skip validation gates** — a phase is not complete until `POST_PHASE.md` succeeds.
+2. **Preserve dependency order** — never execute a task before all of its dependencies are completed.
+3. **Maximize parallelism within each phase** — run all tasks whose dependencies are satisfied simultaneously.
+4. **Fail safely and document everything** — halt on unrecoverable errors, and record all decisions, issues, and outcomes under "Noteworthy Events" in the execution summary.
+## 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 execute a plan 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. Validate tasks and blueprint existence
+Inspect the `taskCount` and `blueprintExists` values returned by the validation script.
+### 4. Auto-generate tasks and blueprint if missing
+If `taskCount` is 0 or `blueprintExists` is `no`:
+- Notify the user: "Tasks or execution blueprint not found. Generating tasks automatically..."
+- Follow the `task-generate-tasks` skill for this plan ID. Execute its operating procedure in full, including running `POST_TASK_GENERATION_ALL.md` to produce the execution blueprint.
+- After generation completes, re-run `scripts/validate-plan-blueprint.cjs <plan-id> planFile` (and the other fields) to refresh the resolved paths and counts.
+If generation still leaves the plan without tasks or a blueprint, stop and report failure. Do not attempt execution without a valid blueprint.
+### 5. Optionally create a feature branch
+Run `scripts/create-feature-branch.cjs <plan-id>`. The script creates a branch named after the plan and prints the branch name. Continue execution regardless of whether a branch is created (some projects may skip this step).
+### 6. Load project context and execution blueprint
+Read these files, in order:
+- `<root>/config/TASK_MANAGER.md` — directory conventions and project context.
+- The plan document at the path returned by step 2.
+- The plan's Execution Blueprint section — this defines the phase groupings and task dispatch order.
+### 7. Execute phases in order
+Use an internal task or todo tracker to monitor progress. For each phase defined in the Execution Blueprint:
+#### 7a. Phase pre-execution
+Read `<root>/config/hooks/PRE_PHASE.md` and execute its instructions before starting the phase.
+#### 7b. Task dispatch
+Identify all tasks scheduled for this phase whose dependencies are fully satisfied. Read `<root>/config/hooks/PRE_TASK_EXECUTION.md` and execute its instructions before starting any implementation work.
+Deploy all selected agents simultaneously using your internal Task tool. Each agent MUST:
+1. Read and execute `<root>/config/hooks/PRE_TASK_EXECUTION.md` before starting any implementation work.
+2. Execute the task according to its requirements.
+3. Monitor execution progress and capture outputs and artifacts.
+4. Update task status in real-time.
+Maximize parallelism within each phase. Run every task that is ready at the same time.
+#### 7c. Phase completion verification
+Ensure every task in the phase has status `completed`. Collect and review all task outputs. Document any issues or exceptions encountered.
+#### 7d. Phase post-execution
+Read `<root>/config/hooks/POST_PHASE.md` and execute its instructions. Do not proceed to the next phase until this hook succeeds.
+Update the phase status to `completed` in the plan's Execution Blueprint section.
+Repeat for the next phase until all phases are complete.
+### 8. Post-execution validation
+Read `<root>/config/hooks/POST_EXECUTION.md` and execute its instructions. If validation fails, halt execution. The plan remains in `plans/` for debugging.
+### 9. Append execution summary
+Append an execution summary section to the plan document using the format described in `<root>/config/templates/EXECUTION_SUMMARY_TEMPLATE.md`. Populate:
+- **Status**: Completed Successfully
+- **Completed Date**: current date
+- **Results**: brief summary of deliverables
+- **Noteworthy Events**: all decisions, issues, and outcomes encountered during execution. If none occurred, state "No significant issues encountered."
+- **Necessary follow-ups**: any follow-up actions or optimizations
+### 10. Archive the plan
+Move the completed plan directory from `<root>/plans/<plan-folder>` to `<root>/archive/<plan-folder>`.
+Preserve the entire folder structure (including all tasks and subdirectories) to maintain referential integrity. If the move fails, log the error but do not fail the overall execution — the implementation work is complete.
+## Failure Modes
+- **No task-manager root found.** Stop and instruct the user to initialize the project. Do not execute any tasks.
+- **Plan ID does not resolve.** Stop and surface the script's stderr to the user. Do not guess a different ID.
+- **Missing blueprint after auto-generation.** If the `task-generate-tasks` skill fails to produce tasks or a blueprint, stop and report failure. Do not attempt execution without a blueprint.
+- **Hook failure.** If `PRE_PHASE.md`, `POST_PHASE.md`, or `POST_EXECUTION.md` fails, halt execution. The plan remains in `plans/` for debugging and potential re-execution.
+- **Execution errors.** If a task fails, read `<root>/config/hooks/POST_ERROR_DETECTION.md`, document the error in Noteworthy Events, halt the phase, and request user direction before continuing.
+## Execution Summary
+Conclude with exactly this block as the final output:
+```
+---
+Execution Summary:
+- Plan ID: [numeric-id]
+- Status: Archived
+- Location: [absolute path to archive directory]
+---
+```
+The summary is consumed by downstream automation; keep the format exact.