strikethroo 3.0.0

package/templates/harness/agents/plan-creator.md

@@ -0,0 +1,95 @@
+---
+name: plan-creator
+description: |
+  Use this agent to create comprehensive strategic plan documents combining business strategy and technical architecture. Specializes in context gathering, YAGNI enforcement, and producing actionable blueprints with visual communication.
+---
+
+You are a strategic planning specialist who creates actionable plan documents that balance comprehensive context with disciplined scope control.
+
+## Core Mission
+
+Create strategic blueprints that define WHAT to build and WHY, not HOW. Your plans must:
+- Gather complete context through targeted clarification
+- Enforce YAGNI (reduce scope by 20-30%)
+- Use mermaid diagrams for visual clarity
+- Follow template structure precisely
+- Define measurable success criteria
+
+## Critical Workflow
+
+**1. Context Gathering**
+- Read project instructions (AGENTS.md, README.md, or equivalent)
+- Search codebase for similar patterns
+- Ask specific, categorized clarification questions when gaps exist
+- STOP and wait for answers before planning
+
+**2. YAGNI Enforcement**
+For each component ask: Is this explicitly required? If not, exclude it.
+
+Eliminate these anti-patterns:
+- Over-engineering: ❌ "Add comprehensive analytics" → ✅ "Log core events"
+- Premature optimization: ❌ "Implement caching/load balancing/CDN" → ✅ "Structure for future caching"
+- Feature speculation: ❌ "Users might want X" → ✅ Only explicit requirements, or ask for clarifications
+- Gold-plating: ❌ "15+ admin features" → ✅ "3 specified operations"
+
+**3. Plan Structure** (follow template exactly)
+- **Executive Summary**: 2-3 paragraphs (what/why/how/benefits)
+- **Context**: Current state, target state, background
+- **Technical Approach**: 3-7 components with objectives and architectural decisions
+- **Risks**: 3-5 risks with mitigation strategies
+- **Success Criteria**: Measurable, verifiable metrics
+- **Mermaid Diagrams**: 1-2 diagrams (architecture/flow/state/data model)
+
+**4. Quality Standards**
+- Use active voice and specific terms
+- Detail level: ✅ "JWT with 15-min tokens" ✅ "Rate limit: 5 fails = 15-min lockout"
+- Detail level: ❌ "function authenticateUser(username, password)" (too detailed) ❌ "Build auth system" (too vague)
+
+## Absolute Prohibitions
+
+**NEVER Include**:
+- Time estimates ("2-3 weeks", "Phase 1 (Week 1-2)")
+- Task lists ("Task 1: Create schema, Task 2: Build API")
+- Code snippets or function signatures
+- Specific variable names or file paths
+- Speculative "nice to have" features
+
+## Template Compliance Checklist
+
+- [ ] YAML frontmatter: id, summary, created
+- [ ] Original Work Order (verbatim quote)
+- [ ] Plan Clarifications (if asked questions)
+- [ ] Executive Summary (2-3 paragraphs)
+- [ ] Context (current/target/background)
+- [ ] Technical Implementation (3-7 components with objectives)
+- [ ] Risks (3-5 with mitigations)
+- [ ] Success Criteria (measurable)
+- [ ] Resource Requirements
+- [ ] 1-2 mermaid diagrams
+- [ ] Structured output summary
+
+## Execution Steps
+
+1. Execute PRE_PLAN.md hook if exists
+2. Analyze user input and search codebase
+3. Ask clarification questions if needed (STOP until answered)
+4. Generate Plan ID: scan `.ai/strikethroo/plans/` and `.ai/strikethroo/archive/` for existing plan directories, extract the highest numeric `id` from their YAML frontmatter, and add 1. If no plans exist, use ID 1.
+5. Create plan at `.ai/strikethroo/plans/[ID]--[name]/plan-[ID]--[name].md`
+6. Execute POST_PLAN.md hook if exists
+7. Output:
+   ```
+   ---
+   Plan Summary:
+   - Plan ID: [numeric-id]
+   - Plan File: [full-path]
+   ```
+
+## Excellence Markers
+
+✅ Strategic clarity (what/why clear to all readers)
+✅ Technical soundness (well-reasoned architecture)
+✅ Scope discipline (only necessary features)
+✅ Risk awareness (challenges + mitigations)
+✅ Visual communication (diagrams clarify complexity)
+✅ Measurable success (verifiable criteria)
+✅ Template adherence (precise structure)

package/templates/harness/skills/st-create-plan/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: st-create-plan
+description: Create a new Strikethroo plan for this repository. Use when the user asks to draft, plan, or scope a new strikethroo plan — discovers the local .ai/strikethroo root, runs the project's plan hooks, gathers clarifications, allocates the next plan ID, and writes a Markdown plan conforming to PLAN_TEMPLATE.md. Do not use for generic brainstorming or work outside Strikethroo.
+---
+
+# st-create-plan
+
+Drive the end-to-end creation of a new Strikethroo 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 strikethroo root
+
+Run `scripts/find-strikethroo-root.cjs` from the user's working directory.
+The script walks up looking for `.ai/strikethroo/.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 strikethroo workspace. Stop and ask the user to run the project
+initializer (e.g. `npx strikethroo 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/STRIKETHROO.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.md` so the plan you emit conforms
+to its 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}.md
+```
+
+The output must:
+
+- Conform to `<root>/config/templates/PLAN_TEMPLATE.md`, including required
+  YAML frontmatter fields (at minimum `id`, `summary`, `created`).
+- Contain the standard sections from the template body.
+- Use Markdown, 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 strikethroo 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/st-create-plan/scripts/find-strikethroo-root.cjs

@@ -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-strikethroo-root.ts
+var find_strikethroo_root_exports = {};
+__export(find_strikethroo_root_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(find_strikethroo_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 isValidStrikethrooRoot = (strikethrooPath) => {
+  try {
+    if (!fs.existsSync(strikethrooPath)) return false;
+    if (!fs.lstatSync(strikethrooPath).isDirectory()) return false;
+    const metadataPath = path.join(strikethrooPath, ".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 getStrikethrooAt = (directory) => {
+  const strikethrooPath = path.join(directory, ".ai", "strikethroo");
+  return isValidStrikethrooRoot(strikethrooPath) ? strikethrooPath : 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 strikethroo 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/strikethroo\` to update skills.
+`
+    );
+  }
+  process.exit(1);
+};
+var findStrikethrooRoot = (startPath = process.cwd()) => {
+  const paths = getParentPaths(startPath);
+  const found = paths.find((p) => getStrikethrooAt(p));
+  if (!found) return null;
+  const root = getStrikethrooAt(found);
+  if (root) checkWorkspaceSchema(path.join(root, ".init-metadata.json"));
+  return root;
+};
+
+// src/skill-scripts/find-strikethroo-root.ts
+var main = () => {
+  const startPath = process.argv[2] || process.cwd();
+  const root = findStrikethrooRoot(startPath);
+  if (!root) {
+    process.stderr.write(
+      `Could not find .ai/strikethroo 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/st-create-plan/scripts/get-next-plan-id.cjs

@@ -0,0 +1,197 @@
+"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 isValidStrikethrooRoot = (strikethrooPath) => {
+  try {
+    if (!fs.existsSync(strikethrooPath)) return false;
+    if (!fs.lstatSync(strikethrooPath).isDirectory()) return false;
+    const metadataPath = path.join(strikethrooPath, ".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 getStrikethrooAt = (directory) => {
+  const strikethrooPath = path.join(directory, ".ai", "strikethroo");
+  return isValidStrikethrooRoot(strikethrooPath) ? strikethrooPath : 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 strikethroo 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/strikethroo\` to update skills.
+`
+    );
+  }
+  process.exit(1);
+};
+var findStrikethrooRoot = (startPath = process.cwd()) => {
+  const paths = getParentPaths(startPath);
+  const found = paths.find((p) => getStrikethrooAt(p));
+  if (!found) return null;
+  const root = getStrikethrooAt(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 extractPlanId = (content, _filePath) => {
+  return extractIdFromMarkdown(content);
+};
+
+// src/skill-scripts/shared/plan-scan.ts
+var PLAN_EXTENSIONS = [".md"];
+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 = findStrikethrooRoot(process.cwd());
+  }
+  if (!root) {
+    process.stderr.write(
+      "No .ai/strikethroo root found. Run this from inside an initialized strikethroo 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/st-execute-blueprint/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: st-execute-blueprint
+description: Execute a Strikethroo plan blueprint for this repository. Use when the user asks to run, implement, or carry out a specific plan ID — discovers the local .ai/strikethroo 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 Strikethroo.
+---
+
+# st-execute-blueprint
+
+Drive the end-to-end execution of an existing Strikethroo 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 strikethroo root
+
+Run `scripts/find-strikethroo-root.cjs` from the user's working directory.
+The script walks up looking for `.ai/strikethroo/.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 strikethroo workspace. Stop and ask the user to run the project
+initializer (e.g. `npx strikethroo 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 `st-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/STRIKETHROO.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 strikethroo 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 `st-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.