@theglitchking/persistent-planning 1.0.0 → 2.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "persistent-planning",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Persistent markdown-based planning with task directories, progress tracking, and context engineering for multi-step Claude Code workflows",
   "author": {
     "name": "TheGlitchKing"

package/CHANGELOG.md

@@ -2,6 +2,81 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.0.0] - 2026-04-18
+
+### ⚠️ Breaking changes
+
+v2.0.0 removes the hand-rolled `persistent-planning install|uninstall`
+flow in favor of standard Claude Code plugin distribution and npm install
+paths. Plugin skill and command files are now delivered **automatically**
+— no manual copy step.
+
+**If you're an existing v1 user**, here's what to expect and how to
+upgrade:
+
+- `persistent-planning install --scope user` is gone. Install instead via
+  the plugin marketplace:
+
+  ```
+  /plugin marketplace add TheGlitchKing/persistent-planning
+  /plugin install persistent-planning@persistent-planning-marketplace
+  ```
+
+  Or, for a project-local install that's visible to teammates and CI:
+
+  ```
+  npm install --save-dev @theglitchking/persistent-planning
+  ```
+
+- `persistent-planning uninstall` is gone. Use `/plugin uninstall` or
+  `npm uninstall @theglitchking/persistent-planning` depending on how you
+  installed it.
+
+- **Old skill/command files in `~/.claude/` or `./.claude/`** placed by
+  v1's installer will keep working until you remove them — but the
+  marketplace plugin and the npm postinstall both place their own copies,
+  so to avoid duplication you should delete the manually-installed
+  copies once you've adopted v2:
+
+  ```
+  # If you installed with --scope user:
+  rm -rf ~/.claude/skills/persistent-planning
+  rm ~/.claude/commands/start-planning.md
+
+  # If you installed with --scope project:
+  rm -rf .claude/skills/persistent-planning
+  rm .claude/commands/start-planning.md
+  ```
+
+- The old `install`/`uninstall` subcommands still exist as deprecation
+  shims — running them prints a migration pointer and exits cleanly
+  instead of failing.
+
+### Added
+- Adopts `@theglitchking/claude-plugin-runtime` for postinstall skill
+  symlinking, SessionStart update nudge/auto-apply, and standardized
+  `update`/`policy`/`status`/`relink` CLI subcommands.
+- Default `updatePolicy: "nudge"` — on session start, the plugin checks
+  npm for a newer version and prints a one-liner when one exists. Opt
+  into `auto` for background auto-update, or `off` to silence entirely.
+- Four new slash commands: `/persistent-planning:update`,
+  `/persistent-planning:policy`, `/persistent-planning:status`,
+  `/persistent-planning:relink`.
+
+### Changed
+- **Skill layout**: `skills/SKILL.md` moved to
+  `skills/persistent-planning/SKILL.md` so the runtime can symlink it
+  into consuming projects' `.claude/skills/persistent-planning/`.
+- **Slash command location**: `.claude/commands/start-planning.md` moved
+  to `commands/start-planning.md` (top-level, matching the marketplace
+  plugin convention).
+- Node >= 20 required (was >= 16).
+
+### Removed
+- `install.sh`, `uninstall.sh`, and the `postinstall.js` banner script.
+- The root-level `plugin.json` — manifest is now only at
+  `.claude-plugin/plugin.json`.
+
 ## [1.0.0] - 2026-02-12
 
 ### Added

package/bin/persistent-planning.js

@@ -1,241 +1,66 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
-const path = require('path');
-
-const PLUGIN_ROOT = path.join(__dirname, '..');
-
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  yellow: '\x1b[33m',
-  red: '\x1b[31m',
-  cyan: '\x1b[36m'
-};
-
-function showHelp() {
-  console.log(`
-${colors.blue}persistent-planning CLI${colors.reset}
-
-${colors.green}Usage:${colors.reset}
-  persistent-planning install [--scope user|project]
-  persistent-planning uninstall [--scope user|project]
-  persistent-planning status
-  persistent-planning help
-
-${colors.green}Commands:${colors.reset}
-  install     Install persistent-planning skill and /start-planning command
-  uninstall   Remove persistent-planning from Claude Code
-  status      Show installation status
-  help        Show this help message
-
-${colors.green}Install Options:${colors.reset}
-  --scope {user|project}    Install scope (default: user)
-                            user     - Install globally (~/.claude/)
-                            project  - Install in current project (.claude/)
-
-${colors.green}Examples:${colors.reset}
-  persistent-planning install --scope user
-  persistent-planning install --scope project
-  persistent-planning uninstall --scope user
-  persistent-planning status
-
-${colors.green}After Installation:${colors.reset}
-  Run this command in Claude Code:
-    /start-planning "Your task name"
-  `);
-}
-
-function copyRecursive(src, dest) {
-  const stats = fs.statSync(src);
-  if (stats.isDirectory()) {
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-    fs.readdirSync(src).forEach(file => {
-      copyRecursive(path.join(src, file), path.join(dest, file));
-    });
-  } else {
-    fs.copyFileSync(src, dest);
+import { program } from "commander";
+import { registerUpdateCommands } from "@theglitchking/claude-plugin-runtime";
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const require_ = createRequire(import.meta.url);
+const { version } = require_("../package.json");
+
+const PKG = "@theglitchking/persistent-planning";
+
+function runRelink(cwd) {
+  const linker = join(cwd, "node_modules", "@theglitchking", "persistent-planning", "scripts", "link-skills.js");
+  const script = existsSync(linker) ? linker : resolve(process.cwd(), "scripts", "link-skills.js");
+  if (!existsSync(script)) {
+    console.error("link-skills.js not found — is the package installed?");
+    return;
   }
+  spawnSync(process.execPath, [script], {
+    cwd,
+    env: { ...process.env, INIT_CWD: cwd },
+    stdio: "inherit",
+  });
 }
 
-function getInstallDir(scope) {
-  return scope === 'user'
-    ? path.join(process.env.HOME || process.env.USERPROFILE, '.claude')
-    : '.claude';
+program
+  .name("persistent-planning")
+  .description("Persistent markdown-based planning for Claude Code.")
+  .version(version);
+
+registerUpdateCommands(program, {
+  packageName: PKG,
+  pluginName: "persistent-planning",
+  configFile: "persistent-planning.json",
+  onAfterUpdate: (cwd) => runRelink(cwd),
+});
+
+// Deprecated subcommands from v1. Accept them so existing automation
+// doesn't silently break — print a migration pointer and exit 0.
+function deprecationNotice(name) {
+  console.error(`\n⚠️  'persistent-planning ${name}' was removed in v2.0.0.\n`);
+  console.error(`The plugin now installs via the Claude Code plugin marketplace:`);
+  console.error(`  /plugin marketplace add TheGlitchKing/persistent-planning`);
+  console.error(`  /plugin install persistent-planning@persistent-planning-marketplace\n`);
+  console.error(`Or, at the project level, via npm:`);
+  console.error(`  npm install --save-dev @theglitchking/persistent-planning\n`);
+  console.error(`See the v2.0.0 CHANGELOG for migration details:`);
+  console.error(`  https://github.com/TheGlitchKing/persistent-planning/blob/main/CHANGELOG.md\n`);
 }
 
-function checkInstallation(scope) {
-  const installDir = getInstallDir(scope);
-  const skillPath = path.join(installDir, 'skills', 'persistent-planning', 'SKILL.md');
-  const commandPath = path.join(installDir, 'commands', 'start-planning.md');
-  return {
-    skill: fs.existsSync(skillPath),
-    command: fs.existsSync(commandPath)
-  };
-}
-
-function showStatus() {
-  console.log(`\n${colors.blue}persistent-planning Installation Status${colors.reset}\n`);
-
-  const userInstall = checkInstallation('user');
-  const projectInstall = checkInstallation('project');
-
-  console.log(`User Scope (~/.claude/):`);
-  console.log(`  Skill:    ${userInstall.skill ? colors.green + 'Installed' : colors.yellow + 'Not installed'}${colors.reset}`);
-  console.log(`  Command:  ${userInstall.command ? colors.green + 'Installed' : colors.yellow + 'Not installed'}${colors.reset}`);
-
-  console.log(`\nProject Scope (./.claude/):`);
-  console.log(`  Skill:    ${projectInstall.skill ? colors.green + 'Installed' : colors.yellow + 'Not installed'}${colors.reset}`);
-  console.log(`  Command:  ${projectInstall.command ? colors.green + 'Installed' : colors.yellow + 'Not installed'}${colors.reset}`);
-
-  if (!userInstall.skill && !projectInstall.skill) {
-    console.log(`\n${colors.yellow}Run: persistent-planning install${colors.reset}`);
-  }
-  console.log();
-}
-
-function runInstall(args) {
-  const scope = args.includes('--scope') ? args[args.indexOf('--scope') + 1] : 'user';
-  const installDir = getInstallDir(scope);
-
-  console.log(`${colors.blue}Installing persistent-planning...${colors.reset}`);
-  console.log(`  Scope: ${scope} (${installDir})\n`);
-
-  try {
-    // Create directories
-    const skillDir = path.join(installDir, 'skills', 'persistent-planning');
-    const scriptsDir = path.join(skillDir, 'scripts');
-    const docsDir = path.join(skillDir, 'docs');
-    const commandsDir = path.join(installDir, 'commands');
+program
+  .command("install")
+  .description("[removed in v2.0.0] use the Claude Code plugin marketplace or npm")
+  .option("--scope <scope>")
+  .action(() => { deprecationNotice("install"); process.exit(0); });
 
-    fs.mkdirSync(scriptsDir, { recursive: true });
-    fs.mkdirSync(docsDir, { recursive: true });
-    fs.mkdirSync(commandsDir, { recursive: true });
+program
+  .command("uninstall")
+  .description("[removed in v2.0.0] use /plugin uninstall or npm uninstall")
+  .option("--scope <scope>")
+  .action(() => { deprecationNotice("uninstall"); process.exit(0); });
 
-    // Copy skill
-    fs.copyFileSync(
-      path.join(PLUGIN_ROOT, 'skills', 'SKILL.md'),
-      path.join(skillDir, 'SKILL.md')
-    );
-    console.log(`${colors.green}+${colors.reset} Installed SKILL.md`);
-
-    // Copy init script
-    const initScript = path.join(scriptsDir, 'init-planning.sh');
-    fs.copyFileSync(
-      path.join(PLUGIN_ROOT, 'scripts', 'init-planning.sh'),
-      initScript
-    );
-    fs.chmodSync(initScript, 0o755);
-    console.log(`${colors.green}+${colors.reset} Installed init-planning.sh`);
-
-    // Copy docs
-    fs.copyFileSync(
-      path.join(PLUGIN_ROOT, 'docs', 'reference.md'),
-      path.join(docsDir, 'reference.md')
-    );
-    fs.copyFileSync(
-      path.join(PLUGIN_ROOT, 'docs', 'examples.md'),
-      path.join(docsDir, 'examples.md')
-    );
-    console.log(`${colors.green}+${colors.reset} Installed reference docs`);
-
-    // Copy command
-    fs.copyFileSync(
-      path.join(PLUGIN_ROOT, '.claude', 'commands', 'start-planning.md'),
-      path.join(commandsDir, 'start-planning.md')
-    );
-    console.log(`${colors.green}+${colors.reset} Installed /start-planning command`);
-
-    // Update .gitignore if project scope
-    if (scope === 'project') {
-      const gitignorePath = '.gitignore';
-      if (fs.existsSync(gitignorePath)) {
-        const content = fs.readFileSync(gitignorePath, 'utf8');
-        if (!content.includes('.claude/')) {
-          fs.appendFileSync(gitignorePath, '\n.claude/\n');
-          console.log(`${colors.green}+${colors.reset} Updated .gitignore`);
-        }
-      } else {
-        fs.writeFileSync(gitignorePath, '.claude/\n');
-        console.log(`${colors.green}+${colors.reset} Created .gitignore`);
-      }
-    }
-
-    console.log(`\n${colors.green}Installation Complete!${colors.reset}\n`);
-    console.log(`${colors.yellow}Usage:${colors.reset}`);
-    console.log(`  In Claude Code, run: ${colors.cyan}/start-planning "Your task name"${colors.reset}\n`);
-    console.log(`${colors.yellow}Uninstall:${colors.reset}`);
-    console.log(`  ${colors.cyan}persistent-planning uninstall --scope ${scope}${colors.reset}\n`);
-
-  } catch (error) {
-    console.error(`${colors.red}Installation failed: ${error.message}${colors.reset}`);
-    process.exit(1);
-  }
-}
-
-function runUninstall(args) {
-  const scope = args.includes('--scope') ? args[args.indexOf('--scope') + 1] : 'user';
-  const installDir = getInstallDir(scope);
-
-  console.log(`${colors.blue}Uninstalling persistent-planning...${colors.reset}`);
-  console.log(`  Scope: ${scope} (${installDir})\n`);
-
-  let removed = 0;
-
-  try {
-    const skillDir = path.join(installDir, 'skills', 'persistent-planning');
-    if (fs.existsSync(skillDir)) {
-      fs.rmSync(skillDir, { recursive: true, force: true });
-      console.log(`${colors.green}+${colors.reset} Removed skill`);
-      removed++;
-    }
-
-    const commandFile = path.join(installDir, 'commands', 'start-planning.md');
-    if (fs.existsSync(commandFile)) {
-      fs.unlinkSync(commandFile);
-      console.log(`${colors.green}+${colors.reset} Removed /start-planning command`);
-      removed++;
-    }
-
-    if (removed === 0) {
-      console.log(`${colors.yellow}Nothing to remove. persistent-planning not found in ${installDir}/${colors.reset}`);
-    } else {
-      console.log(`\n${colors.green}Uninstall complete.${colors.reset}`);
-      console.log(`\nNote: .planning/ directories in your projects are not removed.`);
-      console.log(`To clean those up: rm -rf .planning/\n`);
-    }
-
-  } catch (error) {
-    console.error(`${colors.red}Uninstallation failed: ${error.message}${colors.reset}`);
-    process.exit(1);
-  }
-}
-
-// Main
-const args = process.argv.slice(2);
-const command = args[0];
-
-switch (command) {
-  case 'install':
-    runInstall(args.slice(1));
-    break;
-  case 'uninstall':
-    runUninstall(args.slice(1));
-    break;
-  case 'status':
-    showStatus();
-    break;
-  case 'help':
-  case '--help':
-  case '-h':
-  case undefined:
-    showHelp();
-    break;
-  default:
-    console.error(`${colors.red}Unknown command: ${command}${colors.reset}`);
-    console.log(`Run 'persistent-planning help' for usage information`);
-    process.exit(1);
-}
+program.parse();

package/commands/policy.md

@@ -0,0 +1,16 @@
+---
+description: Get or set the persistent-planning update policy (auto | nudge | off)
+allowed-tools: Bash(npx:*)
+argument-hint: "[auto|nudge|off]"
+---
+
+Arguments: $ARGUMENTS
+
+- If `$ARGUMENTS` is empty, run `npx --no @theglitchking/persistent-planning policy` and report the current policy and config path.
+- If `$ARGUMENTS` is one of `auto`, `nudge`, `off`, run `npx --no @theglitchking/persistent-planning policy $ARGUMENTS` and confirm the new setting to the user.
+- If `$ARGUMENTS` is anything else, tell the user the valid values are `auto`, `nudge`, `off`.
+
+Policies:
+- `auto`  — auto-run `npm update @theglitchking/persistent-planning` at session start when a newer version is available.
+- `nudge` — print a one-liner when a newer version is available (default).
+- `off`   — do not check for updates.

package/commands/relink.md

@@ -0,0 +1,6 @@
+---
+description: Re-run the skill linker — refresh symlinks from node_modules into .claude/skills/
+allowed-tools: Bash(npx:*)
+---
+
+Run `npx --no @theglitchking/persistent-planning relink` and report the result.

package/commands/status.md

@@ -0,0 +1,6 @@
+---
+description: Show installed version, latest available version, current update policy, and hook registration state
+allowed-tools: Bash(npx:*)
+---
+
+Run `npx --no @theglitchking/persistent-planning status` and relay the output to the user verbatim.

package/commands/update.md

@@ -0,0 +1,6 @@
+---
+description: Update persistent-planning to the latest version (runs npm update + re-links skills)
+allowed-tools: Bash(npx:*)
+---
+
+Run `npx --no @theglitchking/persistent-planning update` and report the before/after versions to the user. If the project doesn't have a local install, fall back to `npx -y @theglitchking/persistent-planning update` and note that in your summary.

package/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "description": "persistent-planning SessionStart hook — nudges/auto-updates per policy.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/session-start.js\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/session-start.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// persistent-planning SessionStart hook.
+// Delegates entirely to @theglitchking/claude-plugin-runtime — this plugin
+// has no mcp.json wiring or project-side reconcile, so only the update
+// check runs.
+
+import { runSessionStart } from "@theglitchking/claude-plugin-runtime";
+
+await runSessionStart({
+  packageName: "@theglitchking/persistent-planning",
+  pluginName: "persistent-planning",
+  configFile: "persistent-planning.json",
+});

package/package.json

@@ -1,43 +1,42 @@
 {
   "name": "@theglitchking/persistent-planning",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Persistent markdown-based planning with task directories, progress tracking, and context engineering for multi-step Claude Code workflows",
-  "type": "commonjs",
+  "type": "module",
   "bin": {
-    "persistent-planning": "./bin/persistent-planning.js"
+    "persistent-planning": "bin/persistent-planning.js"
   },
   "scripts": {
-    "postinstall": "node postinstall.js"
+    "postinstall": "node scripts/link-skills.js"
   },
   "files": [
     "bin/",
+    "commands/",
+    "hooks/",
+    "scripts/link-skills.js",
     "skills/",
-    "scripts/",
     "docs/",
-    ".claude/",
     ".claude-plugin/",
-    "postinstall.js",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "keywords": [
     "claude-code",
+    "plugin",
     "planning",
     "persistent",
     "markdown",
     "context-engineering",
     "task-tracking",
     "working-memory",
-    "goal-tracking",
-    "manus",
-    "plugin"
+    "goal-tracking"
   ],
   "author": {
     "name": "TheGlitchKing",
@@ -46,10 +45,14 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TheGlitchKing/persistent-planning.git"
+    "url": "git+https://github.com/TheGlitchKing/persistent-planning.git"
   },
   "bugs": {
     "url": "https://github.com/TheGlitchKing/persistent-planning/issues"
   },
-  "homepage": "https://github.com/TheGlitchKing/persistent-planning#readme"
+  "homepage": "https://github.com/TheGlitchKing/persistent-planning#readme",
+  "dependencies": {
+    "@theglitchking/claude-plugin-runtime": "^0.1.0",
+    "commander": "^14.0.0"
+  }
 }

package/scripts/link-skills.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// Postinstall — delegates to @theglitchking/claude-plugin-runtime.
+// See https://github.com/TheGlitchKing/claude-plugin-runtime/blob/main/docs/PLUGIN_AUTHORING_SCAFFOLD.md
+
+import { runPostinstall } from "@theglitchking/claude-plugin-runtime";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+try {
+  runPostinstall({
+    packageName: "@theglitchking/persistent-planning",
+    pluginName: "persistent-planning",
+    configFile: "persistent-planning.json",
+    skillsDir: "skills",
+    packageRoot,
+    hookCommand:
+      "node ./node_modules/@theglitchking/persistent-planning/hooks/session-start.js",
+  });
+} catch (err) {
+  console.warn(`[persistent-planning] postinstall failed: ${err?.message || err}`);
+}

package/.claude/settings.local.json

@@ -1,13 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bash:*)",
-      "Bash(echo:*)",
-      "Bash(./install.sh:*)",
-      "Bash(/mnt/e/docker-containers/persistent-planning/uninstall.sh:*)",
-      "Bash(chmod:*)",
-      "Bash(node:*)",
-      "Bash(python3:*)"
-    ]
-  }
-}

package/postinstall.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m'
-};
-
-console.log(`
-${colors.cyan}persistent-planning installed successfully!${colors.reset}
-
-${colors.green}+${colors.reset} Package installed: ${colors.blue}@theglitchking/persistent-planning${colors.reset}
-
-${colors.yellow}Next Steps:${colors.reset}
-
-  1. Run the installer to set up the plugin:
-     ${colors.cyan}persistent-planning install --scope user${colors.reset}
-
-     ${colors.blue}Scopes:${colors.reset}
-       user    - Install globally (~/.claude/) for all projects
-       project - Install locally (./.claude/) for this project only
-
-  2. Check installation status:
-     ${colors.cyan}persistent-planning status${colors.reset}
-
-  3. After installation, use this Claude Code command:
-     ${colors.cyan}/start-planning "Your task name"${colors.reset}
-
-${colors.yellow}Documentation:${colors.reset}
-  ${colors.blue}https://github.com/TheGlitchKing/persistent-planning${colors.reset}
-
-`);

package/scripts/init-planning.sh

@@ -1,233 +0,0 @@
-#!/bin/bash
-
-###############################################################################
-# init-planning.sh - Persistent Planning Directory Setup
-#
-# Part of the persistent-planning plugin by TheGlitchKing
-# https://github.com/TheGlitchKing/persistent-planning
-#
-# Usage:
-#   bash scripts/init-planning.sh [task-name]
-#   bash scripts/init-planning.sh "Refactor database layer"
-#
-# What it does:
-#   1. Creates .planning/[task-slug]/ directory (separate per task)
-#   2. Creates task_plan.md with templates
-#   3. Creates notes.md with templates
-#   4. Adds .planning/ to .gitignore (optional)
-#   5. Confirms creation and provides next steps
-#
-# Multiple tasks example:
-#   /start-planning "Refactor auth"      -> .planning/refactor-auth/
-#   /start-planning "Debug memory leak"  -> .planning/debug-memory-leak/
-#   Both plans coexist without conflicts!
-###############################################################################
-
-set -e
-
-# Validate that task name was provided
-if [ -z "$1" ]; then
-    echo "Error: Task name required"
-    echo ""
-    echo "Usage: bash scripts/init-planning.sh \"Your Task Name\""
-    echo ""
-    echo "Examples:"
-    echo "  bash scripts/init-planning.sh \"Refactor authentication\""
-    echo "  bash scripts/init-planning.sh \"Debug API performance\""
-    exit 1
-fi
-
-TASK_NAME="$1"
-
-# Convert task name to slug
-# "Refactor Authentication" -> "refactor-authentication"
-task_name_to_slug() {
-    local name="$1"
-    name=$(echo "$name" | tr '[:upper:]' '[:lower:]')
-    name=$(echo "$name" | sed 's/[[:space:]_]\+/-/g')
-    name=$(echo "$name" | sed 's/[^a-z0-9-]//g')
-    name=$(echo "$name" | sed 's/^-\+\|-\+$//g')
-    name=$(echo "$name" | sed 's/-\+/-/g')
-    echo "$name"
-}
-
-TASK_SLUG=$(task_name_to_slug "$TASK_NAME")
-
-# Validate slug
-if [ -z "$TASK_SLUG" ]; then
-    echo "Error: Task name must contain at least one alphanumeric character"
-    echo "Provided: $TASK_NAME"
-    exit 1
-fi
-
-# Determine project root
-PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-PLANNING_DIR="${PROJECT_ROOT}/.planning"
-TASK_DIR="${PLANNING_DIR}/${TASK_SLUG}"
-
-# Color codes
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-echo -e "${BLUE}Initializing Planning Structure${NC}"
-echo ""
-
-# Step 1: Create .planning directory
-if [ ! -d "$PLANNING_DIR" ]; then
-    mkdir -p "$PLANNING_DIR"
-    echo -e "${GREEN}+${NC} Created .planning/ directory"
-else
-    echo -e "${YELLOW}*${NC} .planning/ directory exists"
-fi
-
-# Step 2: Create task directory
-if [ ! -d "$TASK_DIR" ]; then
-    mkdir -p "$TASK_DIR"
-    echo -e "${GREEN}+${NC} Created task directory: ${CYAN}.planning/${TASK_SLUG}/${NC}"
-else
-    echo -e "${YELLOW}*${NC} Task directory already exists: ${CYAN}.planning/${TASK_SLUG}/${NC}"
-fi
-
-# Step 3: Create task_plan.md
-TASK_PLAN_FILE="${TASK_DIR}/task_plan.md"
-if [ ! -f "$TASK_PLAN_FILE" ]; then
-    cat > "$TASK_PLAN_FILE" << 'EOF'
-# Task Plan: TASK_NAME_PLACEHOLDER
-
-## Goal
-[One sentence describing the end state]
-
-## Phases
-- [ ] Phase 1: Plan and setup
-- [ ] Phase 2: Research/gather information
-- [ ] Phase 3: Execute/build
-- [ ] Phase 4: Review and deliver
-
-## Key Questions
-1. [Question to answer]
-2. [Question to answer]
-
-## Decisions Made
-- [Decision]: [Rationale]
-
-## Errors Encountered
-- [Error]: [Resolution]
-
-## Status
-**Currently in Phase 1** - Setting up planning structure
-
----
-
-## Notes
-- This file persists across sessions
-- Update status after each phase
-- Mark completed phases with [x]
-- Save research to notes.md instead of stuffing context
-EOF
-
-    sed -i "s/TASK_NAME_PLACEHOLDER/${TASK_NAME}/g" "$TASK_PLAN_FILE"
-    echo -e "${GREEN}+${NC} Created task_plan.md"
-else
-    echo -e "${YELLOW}*${NC} task_plan.md already exists (not overwritten)"
-fi
-
-# Step 4: Create notes.md
-NOTES_FILE="${TASK_DIR}/notes.md"
-if [ ! -f "$NOTES_FILE" ]; then
-    cat > "$NOTES_FILE" << 'EOF'
-# Notes: TASK_NAME_PLACEHOLDER
-
-## Key Findings
-- [Finding 1]
-- [Finding 2]
-
-## Research Sources
-- [Source 1]: [URL or reference]
-- [Source 2]: [URL or reference]
-
-## Synthesized Findings
-
-### [Category/Topic 1]
-- [Finding]
-- [Finding]
-
-### [Category/Topic 2]
-- [Finding]
-- [Finding]
-
-## Decisions Made
-- [Decision]: [Rationale]
-- [Decision]: [Rationale]
-
-## Errors & Solutions
-- [Error]: [Resolution]
-- [Error]: [Resolution]
-
----
-
-## Append-Only Log
-Store findings here as you discover them. This builds a searchable history.
-
-### [Date/Time]
-- [What I found/did]
-EOF
-
-    sed -i "s/TASK_NAME_PLACEHOLDER/${TASK_NAME}/g" "$NOTES_FILE"
-    echo -e "${GREEN}+${NC} Created notes.md"
-else
-    echo -e "${YELLOW}*${NC} notes.md already exists (not overwritten)"
-fi
-
-# Step 5: Update .gitignore
-if [ -f "${PROJECT_ROOT}/.gitignore" ]; then
-    if ! grep -q "^\.planning/" "${PROJECT_ROOT}/.gitignore"; then
-        echo ".planning/" >> "${PROJECT_ROOT}/.gitignore"
-        echo -e "${GREEN}+${NC} Added .planning/ to .gitignore"
-    else
-        echo -e "${YELLOW}*${NC} .planning/ already in .gitignore"
-    fi
-else
-    echo -e "${YELLOW}*${NC} No .gitignore found (not added)"
-fi
-
-# Step 6: List other active tasks
-OTHER_TASKS=$(find "$PLANNING_DIR" -maxdepth 1 -type d -not -name ".planning" -not -path "$TASK_DIR" 2>/dev/null | wc -l)
-if [ "$OTHER_TASKS" -gt 0 ]; then
-    echo ""
-    echo -e "${CYAN}Other active tasks:${NC}"
-    find "$PLANNING_DIR" -maxdepth 1 -type d -not -name ".planning" -not -path "$TASK_DIR" | sort | while read dir; do
-        task_slug=$(basename "$dir")
-        echo "   .planning/${task_slug}/"
-    done
-fi
-
-# Step 7: Confirmation
-echo ""
-echo -e "${GREEN}=====================================${NC}"
-echo -e "${GREEN}Task Plan Ready${NC}"
-echo -e "${GREEN}=====================================${NC}"
-echo ""
-
-echo -e "${BLUE}Task:${NC} ${TASK_NAME}"
-echo -e "${BLUE}Location:${NC} .planning/${TASK_SLUG}/"
-echo ""
-
-echo -e "${BLUE}Files:${NC}"
-echo "  task_plan.md   (your task plan)"
-echo "  notes.md       (research & findings)"
-echo ""
-
-echo -e "${BLUE}Next steps:${NC}"
-echo "  1. Edit .planning/${TASK_SLUG}/task_plan.md to define your phases"
-echo "  2. As you work, update the Status section"
-echo "  3. Save findings to .planning/${TASK_SLUG}/notes.md"
-echo "  4. Re-read task_plan.md before major decisions"
-echo ""
-
-echo -e "${BLUE}Cleanup:${NC}"
-echo "  rm -rf .planning/${TASK_SLUG}/  # Remove this task"
-echo "  rm -rf .planning/               # Remove all tasks"
-echo ""