@theglitchking/persistent-planning 1.0.1 → 3.0.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,45 @@
+{
+  "name": "persistent-planning-marketplace",
+  "owner": {
+    "name": "TheGlitchKing",
+    "email": "theglitchking@users.noreply.github.com"
+  },
+  "metadata": {
+    "description": "Official marketplace for persistent-planning - Persistent markdown-based planning for Claude Code. Context engineering pattern with task directories, progress tracking, and working memory that persists across sessions.",
+    "version": "3.0.0"
+  },
+  "plugins": [
+    {
+      "name": "persistent-planning",
+      "description": "Persistent markdown-based planning for Claude Code. Uses on-disk markdown files as working memory for planning, progress tracking, and knowledge storage. Plans persist across sessions and support multiple concurrent tasks.",
+      "version": "3.0.0",
+      "author": {
+        "name": "TheGlitchKing"
+      },
+      "homepage": "https://github.com/TheGlitchKing/persistent-planning",
+      "repository": "https://github.com/TheGlitchKing/persistent-planning.git",
+      "license": "MIT",
+      "keywords": [
+        "planning",
+        "persistent",
+        "markdown",
+        "context-engineering",
+        "task-tracking",
+        "working-memory",
+        "goal-tracking",
+        "claude-code"
+      ],
+      "category": "productivity",
+      "tags": [
+        "planning",
+        "context-engineering",
+        "working-memory"
+      ],
+      "source": {
+        "source": "npm",
+        "package": "@theglitchking/persistent-planning"
+      },
+      "strict": true
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "persistent-planning",
-  "version": "1.0.0",
+  "version": "3.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,138 @@
 
 All notable changes to this project will be documented in this file.
 
+## [3.0.0] - 2026-05-07
+
+### Added — Lg-mode (large/team) layered planning
+
+v3.0 introduces a new **layered planning mode** alongside the existing single-task flow. The mode is auto-detected (90-day git-author-count heuristic; ≥2 distinct authors → lg) and is sticky once chosen.
+
+**Four layers** in lg mode:
+
+- **Phase** — strategic grouping of related tasks (top)
+- **Task** — bounded deliverable; declares `depends_on` + `parallelizable` for subagent team scheduling
+- **Atom** — subagent hand-off unit; sequential within a task; status: `ready | in_progress | done | blocked` with reopen support
+- **Notes** — cross-cutting references scoped to a phase or task
+
+All four layers carry HEWTD-aligned frontmatter (`tier: plan`). `version` is intentionally omitted — HEWTD 2.2.0+ makes it conditionally optional for plan-tier docs.
+
+### Added — `/start-task` and `/start-atom` slash commands
+
+- `/start-task "<name>" --parent <phase>` — adds a task under an existing phase (lg only)
+- `/start-atom "<name>" --parent <task>` — adds an atom (subagent hand-off unit) under a task (lg only); auto-resolves the parent phase by walking `.planning/`; auto-assigns sequence number
+- `/start-planning` updated to dispatch sm vs lg based on detect-mode.sh; accepts `--mode sm|lg` for explicit override
+
+### Added — `.planning/.meta/workspace.json`
+
+Per-project mode tracker. Fields: `schema_version`, `mode`, `auto_detected`, `detected_contributors`, `created_at`. Bootstrapped on first lg-mode init. See `docs/workspace-json.md` for the full schema.
+
+### Added — Documentation
+
+- `docs/lg-mode.md` — full lg-mode guide
+- `docs/atom-granularity.md` — anti-pattern guide for inline-checkbox-vs-standalone-atom
+- `docs/workspace-json.md` — workspace.json schema reference
+
+### Added — Scripts
+
+- `scripts/detect-mode.sh` — sm/lg resolution
+- `scripts/lib/planning.sh` — shared bash helpers
+- `scripts/init-phase.sh`, `scripts/init-task.sh`, `scripts/init-atom.sh` — lg-mode init scripts
+
+### Added — Templates
+
+- `templates/lg/{phase,task,atom,notes}.md` — HEWTD-frontmattered layer templates
+
+### Subagent contract (requires semantic-memory 1.0)
+
+Lg-mode plans are designed to be read by subagents via semantic-memory's MCP verbs (registered conditionally on the `plans` corpus). When semantic-memory is absent, persistent-planning falls back to filesystem-based reads — slash commands still work; subagent comprehension degrades.
+
+### Backwards compatibility
+
+- **Sm mode preserved exactly**: existing `.planning/<task-slug>/{task_plan.md, notes.md}` directories continue to work without changes. The original `/start-planning "Task name"` flow is identical to v2.
+- **Auto-detection is non-disruptive**: existing v2 plans aren't migrated. New `/start-planning` invocations auto-detect mode and create new artifacts using the resolved mode.
+
+### Optional dependencies
+
+- `@theglitchking/hit-em-with-the-docs ^2.2.0` — required for `hewtd validate` to accept lg-mode plan frontmatter (introduces `tier: "plan"` + conditional `version`)
+- `@theglitchking/semantic-memory ^1.0.0` (formerly `semantic-sidekick`) — required for the planning MCP verbs that subagents use to read/mutate lg-mode plans
+
+When neither is installed, lg mode still works as a pure file-authoring flow.
+
+## [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/README.md

@@ -43,43 +43,48 @@ For every complex task, create three files:
 
 ## Installation
 
-### Option 1: NPM (Recommended)
+> **v1 → v2 breaking change**: the hand-rolled `persistent-planning install --scope ...` flow was removed. Skills and slash commands are now placed automatically — either by the Claude Code plugin marketplace, or by npm's postinstall symlinking. See [CHANGELOG.md](./CHANGELOG.md) for the full migration guide.
 
-```bash
-# Install globally
-npm install -g @theglitchking/persistent-planning
-persistent-planning install --scope user
+### Option A: Claude Code Plugin Marketplace (Recommended)
 
-# Or via npx (no global install)
-npx @theglitchking/persistent-planning install --scope user
 ```
+/plugin marketplace add TheGlitchKing/persistent-planning
+/plugin install persistent-planning@persistent-planning-marketplace
+```
+
+### Option B: Project-level npm install
 
-### Option 2: Installer Script
+Pins the exact version in `package.json`, visible to teammates, CI, and LLMs reading the repo. Postinstall symlinks `skills/persistent-planning/` into `<project>/.claude/skills/`, writes a default `.claude/persistent-planning.json` (update policy `nudge`), and registers a SessionStart hook in `.claude/settings.json` if one is present. Dedup: if the plugin marketplace version is already enabled in `~/.claude/settings.json`, the npm hook registration is skipped.
 
 ```bash
-git clone https://github.com/TheGlitchKing/persistent-planning.git
-cd persistent-planning
-./install.sh --scope user       # Available in all projects
-# OR
-./install.sh --scope project    # Current project only
+npm install --save-dev @theglitchking/persistent-planning
 ```
 
-### Option 3: Claude Marketplace
+### Option C: Try it (no install)
 
-```
-/plugin install TheGlitchKing/persistent-planning
+```bash
+npx @theglitchking/persistent-planning status
 ```
 
-### Option 4: Manual Installation
+## Update management
+
+Each install ships with an update policy. By default the plugin checks npm at session start and prints a one-liner when a newer version is available — no changes made. Opt into automatic updates or silence the check entirely:
 
 ```bash
-mkdir -p ~/.claude/skills
-cp -r persistent-planning/skills/SKILL.md ~/.claude/skills/persistent-planning/SKILL.md
-cp -r persistent-planning/scripts ~/.claude/skills/persistent-planning/scripts
-cp -r persistent-planning/docs ~/.claude/skills/persistent-planning/docs
-cp persistent-planning/.claude/commands/start-planning.md ~/.claude/commands/start-planning.md
+# Slash commands
+/persistent-planning:policy auto    # auto-update on session start
+/persistent-planning:policy nudge   # one-liner nudge only (default)
+/persistent-planning:policy off     # silent
+
+# CLI equivalents
+npx --no @theglitchking/persistent-planning policy auto
+npx --no @theglitchking/persistent-planning status     # installed, latest, policy, hook state
+npx --no @theglitchking/persistent-planning update     # runs npm update + relinks skills
+npx --no @theglitchking/persistent-planning relink     # re-symlink skills only
 ```
 
+Policy resolution order: `PERSISTENT_PLANNING_UPDATE_POLICY` env var → `<project>/.claude/persistent-planning.json` → default `nudge`.
+
 ## Usage
 
 ### Quick Start
@@ -151,23 +156,29 @@ Each task gets its own directory. No conflicts, no overwrites.
 ```
 persistent-planning/
 ├── .claude-plugin/
-│   └── plugin.json          # Plugin manifest
-├── .claude/
-│   └── commands/
-│       └── start-planning.md    # /start-planning command
-├── skills/
-│   └── SKILL.md             # Core skill definition
+│   └── plugin.json          # Plugin manifest (marketplace loader)
+├── bin/
+│   └── persistent-planning.js  # CLI (update/policy/status/relink)
+├── commands/
+│   ├── start-planning.md    # /start-planning slash command
+│   ├── update.md            # /persistent-planning:update
+│   ├── policy.md            # /persistent-planning:policy
+│   ├── status.md            # /persistent-planning:status
+│   └── relink.md            # /persistent-planning:relink
+├── hooks/
+│   ├── hooks.json           # SessionStart hook manifest
+│   └── session-start.js     # Runtime-delegated hook
 ├── scripts/
-│   └── init-planning.sh     # Automated setup script
+│   └── link-skills.js       # Postinstall (runtime-delegated)
+├── skills/
+│   └── persistent-planning/
+│       └── SKILL.md         # Core skill definition
 ├── docs/
 │   ├── reference.md         # Manus context engineering principles
 │   └── examples.md          # Worked examples
-├── install.sh               # Plugin installer
-├── uninstall.sh             # Plugin uninstaller
-├── plugin.json              # Root plugin metadata
-├── README.md                # This file
-├── LICENSE                  # MIT license
-└── CHANGELOG.md             # Version history
+├── README.md
+├── LICENSE
+└── CHANGELOG.md
 ```
 
 ## Cleanup

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.