plankit-cli 1.0.0 → 1.0.1

package/src/config.js

@@ -0,0 +1,208 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const DEFAULT_CONFIG = {
+  artifactsDir: 'artifacts',
+  overwrite: 'skip',
+  agents: {
+    codex: true,
+    cursor: true,
+    opencode: true,
+    gemini: true
+  },
+  defaultPhases: [
+    {
+      title: 'Foundation & Setup',
+      slug: 'foundation',
+      objective: 'Establish the base structure, constraints, and integration points.',
+      tasks: ['Confirm scope and constraints', 'Prepare base structure', 'Document implementation notes']
+    },
+    {
+      title: 'Core Implementation',
+      slug: 'core-implementation',
+      objective: 'Implement the primary behavior for the feature.',
+      tasks: ['Implement core changes', 'Update related documentation or examples', 'Record migration notes if needed']
+    },
+    {
+      title: 'Testing & Verification',
+      slug: 'testing-verification',
+      objective: 'Verify behavior and complete the Definition of Done.',
+      tasks: ['Add or update tests', 'Run verification commands', 'Document final outcome']
+    }
+  ],
+  verification: {
+    testCommand: 'npm test',
+    buildCommand: 'npm run build'
+  },
+  templatesDir: null
+};
+
+const CONFIG_FILES = [
+  'plankit.config.json',
+  '.plankitrc.json',
+  path.join('.plankit', 'config.json')
+];
+
+export function loadConfig(cwd = process.cwd()) {
+  const configPath = CONFIG_FILES
+    .map((file) => path.join(cwd, file))
+    .find((file) => fs.existsSync(file));
+
+  if (!configPath) {
+    return { config: normalizeConfig(DEFAULT_CONFIG), path: null };
+  }
+
+  const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  return {
+    config: normalizeConfig(deepMerge(DEFAULT_CONFIG, parsed)),
+    path: configPath
+  };
+}
+
+export function createDefaultConfigFile(cwd, options = {}) {
+  const filePath = path.join(cwd, 'plankit.config.json');
+  const content = `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`;
+  return writeManagedFile(filePath, content, options);
+}
+
+export function normalizeConfig(config) {
+  const normalized = structuredClone(config);
+  normalized.defaultPhases = normalizePhases(normalized.defaultPhases);
+  normalized.artifactsDir = normalized.artifactsDir || DEFAULT_CONFIG.artifactsDir;
+  normalized.overwrite = normalized.overwrite || DEFAULT_CONFIG.overwrite;
+  normalized.agents = { ...DEFAULT_CONFIG.agents, ...(normalized.agents || {}) };
+  normalized.verification = { ...DEFAULT_CONFIG.verification, ...(normalized.verification || {}) };
+  return normalized;
+}
+
+export function normalizePhases(phases) {
+  if (!Array.isArray(phases) || phases.length === 0) {
+    return DEFAULT_CONFIG.defaultPhases;
+  }
+
+  return phases.map((phase, index) => {
+    if (typeof phase === 'string') {
+      return {
+        title: phase,
+        slug: slugify(phase) || `phase-${index + 1}`,
+        objective: `Complete ${phase}.`,
+        tasks: [`Complete ${phase}`, 'Document outcome']
+      };
+    }
+
+    const title = phase.title || `Phase ${index + 1}`;
+    return {
+      title,
+      slug: phase.slug || slugify(title) || `phase-${index + 1}`,
+      objective: phase.objective || `Complete ${title}.`,
+      tasks: Array.isArray(phase.tasks) && phase.tasks.length > 0
+        ? phase.tasks
+        : [`Complete ${title}`, 'Document outcome']
+    };
+  });
+}
+
+export function parsePhaseFlag(value) {
+  if (!value) {
+    return null;
+  }
+
+  const count = Number.parseInt(value, 10);
+  if (String(count) === value && count > 0) {
+    return Array.from({ length: count }, (_, index) => {
+      const defaultPhase = DEFAULT_CONFIG.defaultPhases[index];
+      return defaultPhase || {
+        title: `Phase ${index + 1}`,
+        slug: `phase-${index + 1}`,
+        objective: `Complete Phase ${index + 1}.`,
+        tasks: [`Complete Phase ${index + 1}`, 'Document outcome']
+      };
+    });
+  }
+
+  return normalizePhases(value.split(',').map((item) => item.trim()).filter(Boolean));
+}
+
+export function slugify(value) {
+  return String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function assertSafeName(name, label = 'name') {
+  if (!name || name === '.' || name === '..' || /[\\/]/.test(name) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+    throw new Error(`Invalid ${label} "${name}". Use letters, numbers, ".", "_" or "-" without path separators.`);
+  }
+}
+
+export function safeJoin(root, ...segments) {
+  const resolvedRoot = path.resolve(root);
+  const target = path.resolve(resolvedRoot, ...segments);
+  const relative = path.relative(resolvedRoot, target);
+
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error(`Refusing to access path outside project: ${target}`);
+  }
+
+  return target;
+}
+
+export function ensureDir(dirPath, options = {}) {
+  if (options.dryRun) {
+    return;
+  }
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+export function writeManagedFile(filePath, content, options = {}) {
+  const exists = fs.existsSync(filePath);
+  const same = exists && fs.readFileSync(filePath, 'utf8') === content;
+
+  if (same) {
+    return { path: filePath, action: 'unchanged' };
+  }
+
+  if (exists && !options.force) {
+    return { path: filePath, action: 'skipped' };
+  }
+
+  if (!options.dryRun) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+
+  return { path: filePath, action: exists ? 'updated' : 'created' };
+}
+
+export function listDirectories(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    return [];
+  }
+
+  return fs.readdirSync(dirPath, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function deepMerge(base, override) {
+  if (Array.isArray(base) || Array.isArray(override)) {
+    return override ?? base;
+  }
+
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override ?? base;
+  }
+
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    result[key] = deepMerge(base[key], value);
+  }
+  return result;
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;
+}

package/src/templates.js

@@ -1,149 +1,25 @@
-export const AGENTS_MD_TEMPLATE = `# AGENTS.md — PlanKit Command Suite for AI Agents
-
-All AI coding assistants (Codex, Claude Code, OpenCode, Antigravity, Cursor) interacting with this codebase must follow the **PlanKit Command Suite**:
-
-## Commands
-
-1. \`plankit.plan\` (or \`/plankit-plan\`): Initialize feature under \`artifacts/current/<feature-name>/\`, create \`README.md\` progress matrix, and write \`phases/phase-N-*.md\` specs.
-2. \`plankit.clarify\` (or \`/plankit-clarify\`): Analyze requirements and ask targeted clarifying questions before executing code edits.
-3. \`plankit.implement\` (or \`/plankit-implement\`): Execute Phase N by reading \`phases/phase-N.md\` **AND all previous outputs** (\`outputs/phase-1..N-1-output.md\`), writing \`outputs/phase-N-output.md\`, and updating \`README.md\`.
-4. \`plankit.review\` (or \`/plankit-review\`): Run test & build verification, validate DoD, and move feature folder to \`artifacts/archived/<feature-name>\`.
-
-Canonical Specification: \`artifacts/PLANKIT.md\`
-`;
-
-export const CURSORRULES_TEMPLATE = `# Cursor AI Rules — PlanKit Command Suite
-
-You MUST follow the PlanKit multi-phase feature development standard defined in \`artifacts/PLANKIT.md\`.
-
-## Recognized PlanKit Commands
-
-- **plankit.plan**: Create \`artifacts/current/<feature-name>/\`, master \`README.md\`, and \`phases/phase-N-*.md\` specs.
-- **plankit.clarify**: Inspect codebase & specs, then ask structured clarifying questions before editing code.
-- **plankit.implement**: Read target spec AND \`outputs/phase-1..N-1-output.md\`, execute changes, write \`outputs/phase-N-output.md\`, and mark Phase N \`[x]\` in \`README.md\`.
-- **plankit.review**: Run \`npm run test\` & \`npm run build\`, validate DoD checklist, and move folder to \`artifacts/archived/<feature-name>\`.
-`;
-
-export const GEMINI_INSTRUCTIONS_TEMPLATE = `# Antigravity Workspace Rules — PlanKit Integration
-
-Whenever working in this workspace, strictly adhere to the **PlanKit Command Suite** defined in \`artifacts/PLANKIT.md\`.
-
-## Recognized PlanKit Commands
-
-### 1. \`plankit.plan\` [feature-description]
-- Create \`artifacts/current/<feature-name>/\`.
-- Create \`README.md\` with overview, progress table, and \`[ ]\` checkboxes.
-- Create phase specs in \`phases/phase-N-*.md\`.
-- Present Phase 1 implementation plan.
-
-### 2. \`plankit.clarify\`
-- Read \`artifacts/current/<feature-name>/README.md\` and target spec in \`phases/\`.
-- Inspect codebase and present structured clarifying questions to user before modifying code.
-
-### 3. \`plankit.implement\` [Phase N]
-- Read \`phases/phase-N-*.md\` **AND all previous outputs** (\`outputs/phase-1..N-1-output.md\`).
-- Execute changes, run tests, write \`outputs/phase-N-output.md\`, and update \`README.md\` (\`[x]\`).
-
-### 4. \`plankit.review\`
-- Run \`npm run test\` and \`npm run build\`.
-- Validate DoD checklist.
-- Move completed feature folder from \`artifacts/current/<feature-name>\` to \`artifacts/archived/<feature-name>\`.
-`;
-
-export const OPENCODE_COMMAND_PLAN = `---
-description: Initialize a new feature under artifacts/current/<feature-name>/, create README.md progress matrix, and write phases/phase-N-*.md specs.
----
-
-Initialize a new feature in the workspace according to PlanKit SOP.
-
-Requirements: $ARG
-
-Steps:
-1. Create directory \`artifacts/current/$ARG/\` (or determine feature name from prompt).
-2. Create \`artifacts/current/<feature-name>/README.md\` containing feature overview, architecture summary, DoD checklist, and progress status matrix.
-3. Write phase specification files under \`artifacts/current/<feature-name>/phases/phase-N-<step-name>.md\`.
-4. Generate the detailed Phase 1 implementation plan artifact and request user approval.
-`;
-
-export const OPENCODE_COMMAND_CLARIFY = `---
-description: Analyze requirements and codebase to ask targeted clarifying questions before executing code edits.
----
-
-Analyze requirements and clarify design decisions according to PlanKit SOP.
-
-1. Read \`artifacts/current/<feature-name>/README.md\` and target spec in \`phases/\`.
-2. Inspect relevant codebase files to identify existing patterns, schemas, or potential breaking changes.
-3. Formulate and present structured clarifying questions for the user regarding design choices, API contracts, or edge cases.
-4. Do NOT make code changes until the user responds.
-`;
-
-export const OPENCODE_COMMAND_IMPLEMENT = `---
-description: Execute Phase N by reading phases/phase-N.md AND all previous outputs, writing outputs/phase-N-output.md, and updating README.md.
----
-
-Execute a feature phase according to PlanKit SOP.
-
-Phase to implement: $ARG
-
-1. Read target phase spec: \`artifacts/current/<feature-name>/phases/phase-N-*.md\`.
-2. **Mandatory Context Load**: Read **ALL** previous output reports: \`outputs/phase-1-output.md\` through \`outputs/phase-(N-1)-output.md\`.
-3. Execute code and configuration modifications.
-4. Run automated tests or build verification commands.
-5. Write execution report to \`artifacts/current/<feature-name>/outputs/phase-N-output.md\`.
-6. Update \`artifacts/current/<feature-name>/README.md\`: mark Phase N as \`[x]\` and update status matrix.
-`;
-
-export const OPENCODE_COMMAND_REVIEW = `---
-description: Run test & build verification, validate DoD, and move feature folder to artifacts/archived/<feature-name>.
----
-
-Verify a completed feature and archive it according to PlanKit SOP.
-
-1. Run full test suite (\`npm run test\`) and production build (\`npm run build\`).
-2. Validate all Definition of Done checklist items in \`artifacts/current/<feature-name>/README.md\`.
-3. Update \`README.md\` header title to \`# Feature: <Feature Name> [ARCHIVED]\`.
-4. Move \`artifacts/current/<feature-name>\` directory to \`artifacts/archived/<feature-name>\`.
-5. Present final completion summary report to user.
-`;
-
-export const OPENCODE_COMMAND_MASTER = `---
-description: PlanKit Command Suite master command. Evaluate sub-action (plan, clarify, implement, review).
----
-
-PlanKit Command Suite master command.
-
-Sub-action / Arguments: $ARG
-
-Evaluate the sub-action:
-- \`plan\`: Initialize feature under \`artifacts/current/<feature-name>/\`, create \`README.md\` matrix, and write \`phases/phase-N-*.md\` specs.
-- \`clarify\`: Inspect codebase and specs, then ask structured clarifying questions before implementing code.
-- \`implement\`: Read target spec AND all previous outputs (\`outputs/phase-1..N-1-output.md\`), execute changes, write \`outputs/phase-N-output.md\`, and update \`README.md\`.
-- \`review\`: Run \`npm run test\` & \`npm run build\`, validate DoD checklist, and archive completed feature to \`artifacts/archived/<feature-name>\`.
-`;
-
-export const PLANKIT_SPEC_TEMPLATE = `# PlanKit Command Suite Specification
-
-> [!IMPORTANT]
-> **PlanKit Standard**: PlanKit is a standardized, tool-agnostic command framework for AI coding assistants. It organizes multi-phase feature development into distinct, predictable steps with context-aware execution and automated progress tracking.
-
----
-
-## The 4 Core Commands
-
-### 1. \`plankit.plan\` [feature-name] [requirements]
-- **Purpose**: Initializes a new feature task.
-- **Actions**:
-  1. Creates feature directory: \`artifacts/current/<feature-name>/\`.
-  2. Creates master overview & status tracking table in \`artifacts/current/<feature-name>/README.md\`.
-  3. Creates phase specification files: \`artifacts/current/<feature-name>/phases/phase-1-<name>.md\`, \`phase-2-<name>.md\`, etc.
-  4. Generates initial Phase 1 implementation plan artifact and requests user approval.
-
-### 2. \`plankit.clarify\`
-- **Purpose**: Conducts a structured design alignment and requirements interview.
-
-### 3. \`plankit.implement\` [Phase N]
-- **Purpose**: Executes a single phase with context continuity. Reads \`phases/phase-N.md\` AND all previous outputs (\`outputs/phase-1..N-1-output.md\`).
-
-### 4. \`plankit.review\`
-- **Purpose**: Verifies Definition of Done (DoD) and archives completed features to \`artifacts/archived/\`.
-`;
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+export function renderTemplate(config, templateName, variables = {}, cwd = process.cwd()) {
+  const customPath = config.templatesDir
+    ? path.resolve(cwd, config.templatesDir, templateName)
+    : null;
+
+  const templatePath = customPath && fs.existsSync(customPath)
+    ? customPath
+    : path.join(packageRoot, 'templates', templateName);
+
+  const raw = fs.readFileSync(templatePath, 'utf8');
+  return raw.replace(/\{\{([a-zA-Z0-9_.-]+)\}\}/g, (_, key) => {
+    const value = variables[key];
+    return value === undefined || value === null ? '' : String(value);
+  });
+}
+
+export function renderList(items, mapper) {
+  return items.map(mapper).join('\n');
+}

package/templates/AGENTS.md

@@ -0,0 +1,12 @@
+# AGENTS.md — PlanKit Command Suite for AI Agents
+
+All AI coding assistants interacting with this codebase must follow the PlanKit Command Suite.
+
+## Commands
+
+1. `plankit.plan` / `/plankit-plan`: initialize a feature under `{{artifactsDir}}/current/<feature-name>/`, create `README.md`, and write phase specs.
+2. `plankit.clarify` / `/plankit-clarify`: inspect requirements and ask targeted clarifying questions before executing code edits.
+3. `plankit.implement` / `/plankit-implement`: execute one phase by reading its phase spec and all previous phase outputs.
+4. `plankit.review` / `/plankit-review`: run verification, validate Definition of Done, and archive the feature.
+
+Canonical specification: `{{artifactsDir}}/PLANKIT.md`

package/templates/PLANKIT.md

@@ -0,0 +1,40 @@
+# PlanKit Command Suite Specification
+
+PlanKit is a tool-agnostic command framework for AI coding assistants. It organizes multi-phase feature development into predictable steps with context-aware execution and progress tracking.
+
+## Project Layout
+
+```text
+{{artifactsDir}}/
+  PLANKIT.md
+  current/
+    <feature-name>/
+      README.md
+      plankit.json
+      clarifications.md
+      phases/
+      outputs/
+  archived/
+```
+
+## Core Commands
+
+### `plankit.plan` [feature-name] [requirements]
+
+Initializes a feature task under `{{artifactsDir}}/current/<feature-name>/`.
+
+### `plankit.clarify` [feature-name] [phase]
+
+Creates or updates a clarification artifact for unresolved design and requirement questions.
+
+### `plankit.implement` [feature-name] [phase]
+
+Prepares the phase output artifact after validating that the phase spec and prior phase outputs exist.
+
+### `plankit.review` [feature-name]
+
+Runs configured verification commands and archives the completed feature.
+
+## Customization
+
+Configure PlanKit with `plankit.config.json`. Override generated templates by setting `templatesDir` and matching the package template file names.

package/templates/clarifications.md

@@ -0,0 +1,16 @@
+# Clarifications: {{featureName}}
+
+## Context
+
+- Feature README: `README.md`
+- Target phase: {{phaseLabel}}
+
+## Questions
+
+- [ ] What behavior must be treated as in scope for this phase?
+- [ ] What existing API, schema, or UX contracts must remain stable?
+- [ ] What edge cases should be explicitly handled or deferred?
+
+## Decisions
+
+- Pending.

package/templates/cursorrules

@@ -0,0 +1,10 @@
+# Cursor AI Rules — PlanKit Command Suite
+
+Follow the PlanKit multi-phase feature development standard defined in `{{artifactsDir}}/PLANKIT.md`.
+
+## Recognized PlanKit Commands
+
+- `plankit.plan`: create `{{artifactsDir}}/current/<feature-name>/`, a master `README.md`, and `phases/phase-N-*.md` specs.
+- `plankit.clarify`: inspect the codebase and specs, then ask structured clarifying questions before editing code.
+- `plankit.implement`: read target spec and previous outputs, execute changes, write `outputs/phase-N-output.md`, and update `README.md`.
+- `plankit.review`: run verification, validate DoD, and archive completed feature work.

package/templates/feature-readme.md

@@ -0,0 +1,22 @@
+# Feature: {{featureName}}
+
+## Overview
+
+{{requirements}}
+
+## Phase Breakdown & Progress Status
+
+{{phaseChecklist}}
+
+## Definition of Done
+
+- [ ] Implementation matches the approved phase specs.
+- [ ] Relevant tests or verification commands have passed.
+- [ ] Phase outputs are written under `outputs/`.
+- [ ] Important follow-up work is documented.
+
+## Phase Execution Matrix
+
+| Phase # | Phase Title | Spec Path | Output Path | Status |
+|---|---|---|---|---|
+{{phaseMatrix}}

package/templates/gemini-instructions.md

@@ -0,0 +1,28 @@
+# Antigravity Workspace Rules — PlanKit Integration
+
+Whenever working in this workspace, follow the PlanKit Command Suite defined in `{{artifactsDir}}/PLANKIT.md`.
+
+## Commands
+
+### `plankit.plan` [feature-description]
+
+- Create `{{artifactsDir}}/current/<feature-name>/`.
+- Create `README.md` with overview, progress table, DoD checklist, and status matrix.
+- Create phase specs in `phases/phase-N-*.md`.
+
+### `plankit.clarify`
+
+- Read the feature `README.md` and target phase spec.
+- Inspect relevant codebase files.
+- Ask structured clarifying questions before modifying code.
+
+### `plankit.implement` [phase]
+
+- Read `phases/phase-N-*.md` and all previous `outputs/phase-*-output.md`.
+- Execute changes, run tests where appropriate, write `outputs/phase-N-output.md`, and update `README.md`.
+
+### `plankit.review`
+
+- Run configured verification commands.
+- Validate Definition of Done.
+- Archive the completed feature.

package/templates/opencode/plankit-clarify.md

@@ -0,0 +1,10 @@
+---
+description: Analyze requirements and codebase before executing code edits.
+---
+
+Analyze requirements and clarify design decisions according to PlanKit.
+
+1. Read `{{artifactsDir}}/current/<feature-name>/README.md` and target spec in `phases/`.
+2. Inspect relevant codebase files.
+3. Present targeted clarifying questions about design choices, API contracts, or edge cases.
+4. Do not make code changes until required clarifications are resolved.

package/templates/opencode/plankit-implement.md

@@ -0,0 +1,14 @@
+---
+description: Execute Phase N by reading phase spec and all previous outputs.
+---
+
+Execute a feature phase according to PlanKit.
+
+Phase to implement: $ARG
+
+1. Read target phase spec under `{{artifactsDir}}/current/<feature-name>/phases/`.
+2. Read all previous output reports from `outputs/`.
+3. Execute scoped code and configuration changes.
+4. Run relevant verification commands.
+5. Write execution report to `outputs/phase-N-output.md`.
+6. Update the feature `README.md`.

package/templates/opencode/plankit-plan.md

@@ -0,0 +1,13 @@
+---
+description: Initialize a new feature under {{artifactsDir}}/current/<feature-name>/.
+---
+
+Initialize a new feature in the workspace according to PlanKit.
+
+Requirements: $ARG
+
+Steps:
+1. Create `{{artifactsDir}}/current/<feature-name>/`.
+2. Create `README.md` with overview, architecture notes, DoD checklist, and progress matrix.
+3. Write phase specification files under `phases/phase-N-<step-name>.md`.
+4. Present Phase 1 implementation plan and request approval when required.

package/templates/opencode/plankit-review.md

@@ -0,0 +1,11 @@
+---
+description: Run verification, validate DoD, and archive a completed feature.
+---
+
+Verify a completed feature and archive it according to PlanKit.
+
+1. Run configured test and build commands.
+2. Validate Definition of Done checklist items in the feature `README.md`.
+3. Update the feature title to indicate archive state.
+4. Move the feature directory from `{{artifactsDir}}/current/` to `{{artifactsDir}}/archived/`.
+5. Present final completion summary.

package/templates/opencode/plankit.md

@@ -0,0 +1,12 @@
+---
+description: PlanKit Command Suite master command.
+---
+
+Sub-action / Arguments: $ARG
+
+Evaluate the sub-action:
+
+- `plan`: initialize a feature under `{{artifactsDir}}/current/<feature-name>/`.
+- `clarify`: inspect codebase and specs, then ask structured clarifying questions.
+- `implement`: read target spec and previous outputs, execute changes, write phase output, and update README.
+- `review`: run verification, validate DoD, and archive completed feature work.

package/templates/output-report.md

@@ -0,0 +1,17 @@
+# Phase {{phaseNumber}} Output: {{phaseTitle}}
+
+## Summary
+
+Pending implementation summary.
+
+## Changes Made
+
+- Pending.
+
+## Verification
+
+- Pending.
+
+## Follow-ups
+
+- Pending.

package/templates/phase-spec.md

@@ -0,0 +1,19 @@
+# Phase {{phaseNumber}}: {{phaseTitle}}
+
+## 1. Objective
+
+{{objective}}
+
+## 2. Tasks
+
+{{tasks}}
+
+## 3. Inputs
+
+- Feature README: `../README.md`
+- Previous outputs: `../outputs/phase-1-output.md` through `../outputs/phase-{{previousPhaseNumber}}-output.md`, when applicable.
+
+## 4. Expected Output
+
+- Implementation changes scoped to this phase.
+- Output report: `../outputs/phase-{{phaseNumber}}-output.md`