strikethroo 3.0.0

package/templates/harness/skills/st-refine-plan/scripts/validate-plan-blueprint.cjs

@@ -0,0 +1,358 @@
+"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 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));
+  });
+};
+
+// src/skill-scripts/shared/plan-resolve.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var isValidRootDir = (strikethrooPath) => {
+  try {
+    if (!fs3.existsSync(strikethrooPath)) return false;
+    if (!fs3.lstatSync(strikethrooPath).isDirectory()) return false;
+    const metadataPath = path3.join(strikethrooPath, ".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) !== "strikethroo") 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) || findStrikethrooRoot(path3.dirname(absolutePath));
+  if (!tmRoot) return null;
+  return {
+    planFile: absolutePath,
+    planDir: path3.dirname(absolutePath),
+    strikethrooRoot: tmRoot,
+    planId
+  };
+};
+var resolveByIdInAncestry = (planId, startPath, searched = /* @__PURE__ */ new Set()) => {
+  const tmRoot = findStrikethrooRoot(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,
+      strikethrooRoot: 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",
+  "strikethrooRoot",
+  "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 = findStrikethrooRoot(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,
+    strikethrooRoot: resolved.strikethrooRoot,
+    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/strikethroo/README.md

@@ -0,0 +1,7 @@
+# Strikethroo
+
+This directory contains AI-assisted task management files for this project.
+
+Managed by the [Strikethroo](https://www.github.com/e0ipso/strikethroo) project.
+
+**Documentation**: https://mateuaguilo.com/strikethroo

package/templates/strikethroo/config/STRIKETHROO.md

@@ -0,0 +1,76 @@
+# Strikethroo General Information
+
+This document contains important information that is common to all the
+Strikethroo skills your AI assistant uses to plan, decompose, and execute work.
+
+## Types of Documents
+
+Work orders (abbreviated as WO) are complex prompts for programming,
+organizational, or management tasks created by a user. Work orders are
+independent of each other and cannot share any context. By definition
+different work orders can be worked on independently.
+
+Each work order has plan associated to it. The plan is a comprehensive document
+highlighting all the aspects of the work necessary to accomplish the goals from
+the work order.
+
+Each plan will be broken into tasks. Each task is a logical unit of work that
+has a single purpose, and is solved using a single skill. All tasks exist as
+part of a plan. Tasks can have dependencies on other tasks. This happens when a
+task cannot be worked on (or completed) before some other task(s) are completed.
+
+## Directory Structure
+
+To find a plan document from its ID use the following command (replace {planId} with the ID, like 06):
+```shell
+find .ai/strikethroo/{plans,archive} -name "plan-[0-9][0-9]*--*.md" -type f -exec grep -l "^id: \?{planId}$" {} \;
+```
+
+Plans, and tasks are stored as MarkDown files with a YAML front-matter. They are
+all filed under the `.ai/strikethroo/` folder at the root of the repository.
+
+Plans are organized as follows:
+
+```
+.ai/
+  strikethroo/
+    plans/           # Active plans (work in progress)
+      01--authentication-provider/
+        plan-01--authentication-provider.md
+        tasks/
+          01--create-project-structure.md
+          02--implement-authorization.md
+          03--this-example-task.md
+          04--create-tests.md
+          05--update-documentation.md
+    archive/         # Completed plans (successfully executed)
+      05--user-management/
+        plan-05--user-management.md
+        tasks/
+          01--create-user-model.md
+          02--implement-crud-operations.md
+          03--add-validation.md
+```
+
+Note how in the `.ai/strikethroo/plans/` folder we have a sub-folder per plan.
+Each sub-folder will contain the plan document and has a name following a naming
+pattern `[ID]--[plan-short-name]`. Where the ID is auto-incremental. The plan
+document has a name following the pattern `plan-[ID]--[plan-short-name].md`.
+Finally, all tasks are under a `tasks` sub-folder. Each task has a name
+according to the pattern `[incremental-ID]--[task-short-name].md`. IDs for tasks
+are auto-incremental within a plan. Each plan starts their tasks' IDs from 01.
+
+## Plan Lifecycle and Archive System
+
+Plans follow a lifecycle that maintains workspace organization:
+
+1. **Active Plans**: When created, plans are placed in the `plans/` directory where they remain while being worked on.
+
+2. **Completed Plans**: Upon successful execution of a blueprint (via the `st-execute-blueprint` skill), the entire plan directory is automatically moved from `plans/` to `archive/`.
+
+3. **Archive Directory**: The `archive/` directory serves as permanent storage for completed work. This separation keeps the active workspace clean while preserving completed plans for reference.
+
+The archive system provides several benefits:
+- **Workspace Organization**: Active plans remain easily accessible while completed work doesn't clutter the workspace
+- **Historical Reference**: Completed plans and their tasks remain available for future reference or learning
+- **Automatic Management**: No manual intervention required - archival happens automatically upon successful completion

package/templates/strikethroo/config/hooks/POST_ERROR_DETECTION.md

@@ -0,0 +1,46 @@
+# POST_ERROR_DETECTION Hook
+
+## Task Execution Error Handling
+
+If task execution fails:
+
+```bash
+# On execution failure, update status to failed
+echo "Task execution failed - updating status..."
+
+TEMP_FILE=$(mktemp)
+awk '
+    /^---$/ {
+        if (++delim == 1) {
+            print
+            next
+        } else if (delim == 2) {
+            print "status: \"failed\""
+            print
+            next
+        }
+    }
+    /^status:/ && delim == 1 {
+        print "status: \"failed\""
+        next
+    }
+    { print }
+' "$TASK_FILE" > "$TEMP_FILE"
+
+mv "$TEMP_FILE" "$TASK_FILE"
+
+echo "Task ${TASK_ID} marked as failed"
+echo "Check the task requirements and try again"
+exit 1
+```
+
+## Validation Gate Failure Handling
+
+#### Validation Gate Failures
+If validation gates fail:
+1. Document which specific validations failed
+2. Identify which tasks may have caused the failure
+3. Generate remediation plan
+4. Re-execute affected tasks after fixes
+5. Re-run validation gates
+6. If errors persist, escalate to the user

package/templates/strikethroo/config/hooks/POST_EXECUTION.md

@@ -0,0 +1,25 @@
+# POST_EXECUTION Hook
+
+## Validation Gates
+
+Before marking the blueprint as complete, verify:
+
+- [ ] All linting rules must pass without errors. If no linter is configured, skip this step
+- [ ] All tests must pass successfully. If no test suite is configured, skip this step
+- [ ] Verify all tasks in the plan have `status: "completed"` in their frontmatter
+- [ ] Verify that the AGENTS.md documentation or related documentes are still correct after this plan execution
+- [ ] Execute the **Self Validation** steps defined in the plan document. These are concrete verification procedures (e.g., Playwright browser checks, database CLI queries, screenshots) that confirm the implementation works in the real system. If any step fails, treat it as a validation gate failure
+
+## Cleanup
+Assess weather the current plan has left tech debt behind or if it has created dead code. None of those are acceptable. Fix them and leave behind the most maintainable code change possible.
+
+Backwards compatibility and legacy support are only tolerated if explicitly expressed by the user. Unless it is called out in the plan, you are to assume that backwards compatibility layers are tech debt that should be eliminated.
+
+## Failure Behavior
+
+If any validation gate fails:
+
+- **Halt execution immediately** - do not proceed to summary generation or archival
+- **Leave plan in `plans/` directory** for debugging and correction
+- **Document the failure** in the plan file with details about which gate failed
+- **Provide actionable next steps** for resolving the failure

package/templates/strikethroo/config/hooks/POST_PHASE.md

@@ -0,0 +1,24 @@
+# POST_PHASE Hook
+
+Ensure that:
+
+ - The code base is passing the linting requirements
+ - A descriptive commit (using conventional commits with a subject and a description) for the phase was successfully created.
+
+### Execution Monitoring
+
+#### Progress Tracking
+
+Update the list of tasks from the plan document to add the status of each task
+and phase. Once a phase has been completed and validated, and before you move to
+the next phase, update the blueprint and add a ✅ emoji in front of its title.
+Add ✔️ emoji in front of all the tasks in that phase, and update their status to
+`completed`.
+
+#### Task Status Updates
+Valid status transitions:
+- `pending` → `in-progress` (when agent starts)
+- `in-progress` → `completed` (successful execution)
+- `in-progress` → `failed` (execution error)
+- `failed` → `in-progress` (retry attempt)
+

package/templates/strikethroo/config/hooks/POST_PLAN.md

@@ -0,0 +1,5 @@
+# POST_PLAN Hook
+
+Ensure the plan includes a _Self Validation_ section describing the steps the LLM will take to validate that the plan was completed successfully.
+
+Also, answer the question _Does this plan need to update the documentation, or the AGENTS.md_.

package/templates/strikethroo/config/hooks/POST_TASK_GENERATION_ALL.md

@@ -0,0 +1,41 @@
+# POST_TASK_GENERATION_ALL Hook
+
+After all tasks have been generated, perform these two steps:
+
+## 1. Review Task Complexity
+
+For each generated task, do a quick sanity check:
+
+- **Too complex?** If a task spans 3+ technologies or requires 3+ skills, split it.
+- **Too vague?** If acceptance criteria are unclear, sharpen them.
+- **Too trivial?** If two tasks could be one without adding complexity, merge them.
+
+Target: every task should be completable with 1-2 skills and have clear acceptance criteria.
+
+## 2. Update Plan with Blueprint
+
+After finalizing tasks, append to the plan document:
+
+### Dependency Diagram
+
+If tasks have dependencies, add a Mermaid graph:
+
+```mermaid
+graph TD
+    001[Task 001: Description] --> 002[Task 002: Description]
+```
+
+Verify there are no circular dependencies.
+
+### Execution Phases
+
+Group tasks into phases:
+- **Phase 1**: Tasks with no dependencies (run in parallel)
+- **Phase N**: Tasks whose dependencies are all in earlier phases
+
+Use the template in `.ai/strikethroo/config/templates/BLUEPRINT_TEMPLATE.md` for structure.
+
+Before finalizing, verify:
+- Every task is in exactly one phase
+- No task runs before its dependencies complete
+- Phase 1 has only zero-dependency tasks

package/templates/strikethroo/config/hooks/PRE_PHASE.md

@@ -0,0 +1,21 @@
+# PRE_PHASE Hook
+
+## Phase Pre-Execution
+
+### Feature Branch Creation
+
+Create a feature branch for this plan execution:
+
+- From `main`/`master` with a clean working tree: create a branch named `feature/{planId}--{plan-name}` and switch to it.
+- From `main`/`master` with uncommitted changes: halt with an error — do not proceed.
+- Already on a feature branch: proceed without creating a new branch.
+- Branch already exists: switch to it and proceed normally.
+
+## Phase Execution Workflow
+
+1. **Phase Initialization**
+    - Identify current phase from the execution blueprint
+    - List all tasks scheduled for parallel execution in this phase
+    - **Validate Task Dependencies**: For each task in the current phase, verify that all declared dependencies (from the task's YAML frontmatter `dependencies` array) have status `completed`. If any dependency is unresolved, halt the phase and report the blocking dependencies before continuing.
+    - Confirm no tasks are marked "needs-clarification"
+    - If any phases are marked as completed, verify they are actually completed and continue from the next phase.

package/templates/strikethroo/config/hooks/PRE_PLAN.md

@@ -0,0 +1,42 @@
+# PRE_PLAN Hook
+
+## Scope Control Guidelines
+
+**Critical: Implement ONLY what is explicitly requested**
+
+- **Minimal Viable Implementation**: Build exactly what the user asked for, nothing more
+- **Question Everything Extra**: If not directly mentioned by the user, don't add it
+- **Avoid Feature Creep**: Resist the urge to add "helpful" features or "nice-to-have" additions
+- **YAGNI Principle**: _You Aren't Gonna Need It_ - don't build for hypothetical future needs
+- **Do NOT add backwards compatibility, unless requested**: If there is a potential BC break, ask the user if they want to BC support. Do not assume the want it.
+
+**Common Scope Creep Anti-Patterns to Avoid:**
+1. Adding extra commands or features "for completeness"
+2. Creating infrastructure for future features that weren't requested
+3. Building abstractions or frameworks when simple solutions suffice
+4. Adding configuration options not specifically mentioned
+5. Implementing error handling beyond what's necessary for the core request
+6. Creating documentation or help systems unless explicitly requested
+
+**When in doubt, ask**: "Is this feature explicitly mentioned in the user's request?"
+
+## Simplicity Principles
+
+**Favor maintainability over cleverness**
+
+- **Simple Solutions First**: Choose the most straightforward approach that meets requirements
+- **Avoid Over-Engineering**: Don't create complex systems when simple ones work
+- **Readable Code**: Write code that others can easily understand and modify
+- **Standard Patterns**: Use established patterns rather than inventing new ones
+- **Minimal Dependencies**: Add external dependencies only when essential, but do not re-invent the wheel
+- **Clear Structure**: Organize code in obvious, predictable ways
+
+**Remember**: A working simple solution is better than a complex "perfect" one.
+
+## Critical Notes
+
+- Never generate a partial or assumed plan without adequate context
+- Prioritize accuracy over speed
+- Consider both technical and non-technical aspects
+- Use the plan template in .ai/strikethroo/config/templates/PLAN_TEMPLATE.md
+- DO NOT create or list any tasks or phases during the plan creation. This will be done in a later step. Stick to writing the PRD (Project Requirements Document).