planrails 0.1.2 → 0.2.0

package/README.md

@@ -1,225 +1,152 @@
 # planrails
 
-**Plans that survive compaction, for Claude Code.** A plan lives in files, not in the chat. A task is done only when a gate ran and every condition of done was answered. Hooks put the plan in front of the agent at the moments it matters: session start, after a compaction, at the tool call, before it stops.
+**Plans that survive a lost session, and "done" that means done.** A planner
+prompt your AI agent reads, and one small checker. Set it up in one command.
 
-```bash
-npx planrails init        # in a new directory or an existing project
-# restart Claude Code, then type:  /plan <your raw plan>
-```
-
-Built and used on a real project for a day before it was extracted, with the reviews, the black-box trial and the measurements that shaped it recorded in the guide it ships with.
-
-## The problem it solves
-
-A Claude Code session forgets. Compaction keeps your messages and drops every tool result, so the agent loses the record of what it already did. A new session starts blind. The usual fixes make things worse: progress notes written from memory at the end of a session go stale, and every rule learned gets pasted into CLAUDE.md until the file is huge and re-read on every call.
+Long tasks lose their thread. A coding session compacts or ends, and the next one
+starts blind: it repeats work, or it trusts a status line that says "done" over
+work that is not. planrails fixes that with three plain rules and almost no code.
 
-Three habits break under that pressure, and planrails is built against each:
+1. **The plan reloads itself.** One line in the file your agent always reads
+   re-opens the plan after every compaction. The state is never lost.
+2. **Every task names its proof before the work starts** — the command that will
+   show it is done. No command, no way to fake it later.
+3. **A task is done only when its proof was run and pasted in.** An empty evidence
+   cell is not done, whatever the status says. A small, dependency-free checker
+   enforces this in your build.
 
-| the habit | what planrails does instead |
-|---|---|
-| Progress is remembered, then written down late. | Progress is written **as it happens**, through a CLI, into small append-only files. A hook renders a short brief from those files at every session start and after every compaction. |
-| Every rule goes into the always-loaded file. | A rule is attached to the step it applies to. A hook injects it at that tool call, once. The brief stays under 6,000 characters. |
-| "Done" is a word an agent types. | A task is done only through `task done`, which runs the task's gate, records the run, and needs every condition of done answered in words. The validator refuses a done task that no recorded run backs, whoever wrote the file. |
-
-## Requirements
-
-- Node 20.10 or newer.
-- Claude Code (hooks measured on 2.1.269).
-- `jq` on the PATH only if you turn on the optional never-delete guard.
+It works in any project — Node, Python, Go, a monorepo, Windows — because it adds
+two files and changes nothing else.
 
 ## Getting started
 
-### A new repository
+### One command, any project
 
-You have an empty directory and an idea.
+From the root of your project:
 
 ```bash
-mkdir my-app && cd my-app
-git init
 npx planrails init
 ```
 
-What you will see:
+That copies two files into `.project-management/` and makes the `plans/` folder.
+It writes **nothing else** — no `package.json`, no `npm install`, no hooks, no
+edits to your `CLAUDE.md`. Run it again any time; it skips files that already
+exist. What lands:
 
 ```
-planrails 0.1.0 → /Users/you/my-app
-installing planrails@0.1.0 as a devDependency…
-
-  + wrote a minimal package.json
-  + installed planrails@0.1.0 as a devDependency
-  + copied docs/PLANNING_GUIDE.md
-  + created .project-management/plans/
-  + created CLAUDE.md with a Project management section
-  + added the generated plans block to CLAUDE.md
-  + added npm scripts (plan, plan:doctor, plan:brief, plan:validate)
-  + added .planrails/ to .gitignore
-  + wrote the hooks into .claude/settings.json
-
-doctor: healthy
-
-Next: restart Claude Code (or run /hooks), then type:  /plan <your raw plan>
+.project-management/
+  PLANNER.md          the prompt your agent follows to plan and execute
+  check-plans.mjs     the checker (the one machine-enforced rail)
+  plans/              your plans will live here, one folder each
 ```
 
-Then:
+Then, two steps:
 
-1. Start Claude Code in the directory (or run `/hooks` if it was already open) so the hooks load.
-2. Type `/plan` followed by what you want to build, in your own words. For example: `/plan A CLI that greets people: greet.mjs prints "Hello, <name>!" from the first argument, or "Hello, world!" with none. A test file proves both. A README explains both.`
-3. The planner asks the questions your text did not answer, in one message. Answer them.
-4. It writes the plan, proves every gate can fail, activates the plan, and shows you its brief.
+1. **Tell your agent to plan with you.** In any coding agent:
 
-Commit everything, including `.claude/settings.json`: the hook commands use `$CLAUDE_PROJECT_DIR`, which Claude Code sets on every machine, so teammates get the hooks after `npm install`.
+   > Follow `.project-management/PLANNER.md` and tell me when you are ready to
+   > plan the next feature with me.
 
-### An existing repository
+   It reads your repo, reports what it found in eight lines, and waits. Then you
+   plan together, and it writes the plan and wires the reload line.
 
-You have a project with its own CLAUDE.md, its own hooks, its own check script. `init` adds and never replaces.
+2. **Wire the checker into your build.** Add this to the command you run before
+   every commit (your `check` / `lint` / CI script):
 
-```bash
-cd my-existing-project
-npx planrails init --dry-run     # shows what would change, writes nothing
-npx planrails init
-```
+   ```bash
+   node .project-management/check-plans.mjs
+   ```
 
-What changes, and what does not:
+   Now the build fails if any task is marked done without pasted evidence.
 
-| it | what init does |
-|---|---|
-| `package.json` | adds planrails as a devDependency and four `plan:*` scripts; appends `planrails validate --all --quiet` to an existing `check` script |
-| `CLAUDE.md` | appends a "Project management" section if there is none, and a small generated block that lists the active plans. Your text is untouched. |
-| `.claude/settings.json` | adds the six planrails hooks next to the hooks you already have. Other settings are untouched. A backup goes to `.planrails/backups/` first. |
-| `docs/PLANNING_GUIDE.md` | copied in, unless a file by that name exists |
-| `.project-management/plans/` | created, empty |
-| `.gitignore` | gains `.planrails/` |
+That is the whole setup.
 
-Run it twice and the second run reports nothing added. `npx planrails uninstall` removes the hooks and the skill and leaves your plans alone.
+### New project vs existing project
 
-### Planning your first feature, step by step
+The command is the same; the difference is what your agent sees.
 
-Say the project is a web app and you want a weekly digest email.
+- **New project:** there is nothing to read yet, so the agent asks you a few
+  questions (goal, done-when, what it must not change) and writes the first plan.
+- **Existing project:** the agent first reads your `CLAUDE.md`/`README`, your
+  `docs/`, and recent commits, and reports what it found before planning — so the
+  plan fits how your code already works. `init` is safe to run in a project that
+  already has files or its own `.project-management/`; it only adds, never
+  overwrites (without `--force`).
 
-**1. Ask for a plan.** In a Claude Code session in the project:
+### Without npm, or a non-Node project
 
-```
-/plan Weekly digest email: every Monday 07:00, send each subscriber the five most-read posts of the week. Reuse the existing email seam. A subscriber can turn it off from their settings page.
-```
+No npm? Copy the two files by hand from this repo:
+[`PLANNER.md`](PLANNER.md) → `.project-management/PLANNER.md`, and
+[`tools/check-plans.mjs`](tools/check-plans.mjs) →
+`.project-management/check-plans.mjs`. Make a `.project-management/plans/`
+folder. Done.
 
-**2. Answer the questions.** The planner asks only what your text left open, in one message. For example: what proves done, which files may change, who approves the first real send.
+The checker needs Node to run. If your project has no Node at all, skip it — the
+plan still works, and your agent enforces the gate the way `PLANNER.md` says. The
+planner method does not depend on any language.
 
-**3. Read what it wrote.** A plan is one folder, `.project-management/plans/weekly-digest/`:
+### As a `/plan` command in Claude Code
 
-| file | what it holds |
-|---|---|
-| `PLAN.md` | why, the method, the rules, the map of files |
-| `state.json` | every task with its status, its gate, its evidence, its answered conditions. Written only by the CLI. |
-| `gates.json` | what proves each task done: a command, what it does not check, a case that must fail |
-| `rules.json` | rules a hook shows the agent when it touches a matching file or runs a matching command |
-| `log.jsonl`, `learnings.jsonl`, `decisions.jsonl`, `gate-runs.jsonl` | append-only history |
+Copy [`skill/`](skill) to `~/.claude/skills/plan/`, and put a copy of `PLANNER.md`
+beside it in the same folder. Then `/plan` starts the same flow in any project.
 
-The gates are the project's own commands: the test runner on the digest module, the lint, a script that enqueues one digest against a throwaway database. Each one declares a known-fail case, and the planner ran `gate verify --all` before activating, so you know each gate can actually fail.
+## How a plan works
 
-**4. Execute, one task at a time.** Open a new session, or continue. The brief is already in the agent's context:
+Each plan is two files: `PLAN.md` (the map and tracker) and `LOG.md` (append-only
+history). The top of `PLAN.md` is what a fresh session reads first:
 
 ```
-## Plan weekly-digest — Weekly digest email
-active · 0/4 tasks done · 0 doing · 0 blocked
-RESUME: start T1: the digest query, lib/digest/query.ts
-NOW T1: … — proves done by G1 · effort high
-RULES FOR THIS PLAN: …
-JUDGMENT OUTRANKS THE GATE: a red gate is never made to pass, a green gate is never trusted blind …
+## NOW
+RESUME: T2 — render the digest through lib/email (lib/digest/render.ts)
+NEXT: T3 schedule · T4 docs
+updated: 2026-09-12 14:20
+
+## Tasks
+| id | task | status | proof | evidence |
+|----|------|--------|-------|----------|
+| T1 | the digest query (lib/digest/query.ts) | done  | `npx vitest run tests/digest.test.ts` | 2026-09-12 14:05 · exit 0 · "6 passed" |
+| T2 | render through the email seam       | doing | `npx vitest run tests/render.test.ts` | |
 ```
 
-The loop for each task:
+The full method — how the agent gets ready, interviews you, writes the plan, and
+runs one task at a time — is in [`PLANNER.md`](PLANNER.md). A complete worked plan
+is in [`examples/weekly-digest/`](examples/weekly-digest).
+
+## The checker
 
 ```bash
-npx planrails task start weekly-digest T1
-# … the work …
-npx planrails log weekly-digest --task T1 --what "query returns the top 5 posts by reads over 7 days (lib/digest/query.ts)" --next "T2: render with the email seam"
-npx planrails task check weekly-digest T1     # every condition of done, plus the gate's blind spots
-npx planrails task done weekly-digest T1 --answer "C4: docs/EMAIL_GUIDE.md § Digest updated" --answer "C5: the 5 is the LIMIT in query.ts:12" --answer "C6: nothing new" --answer "C7: read query.ts whole; the gate cannot see a wrong week boundary, I checked Monday 00:00 by hand"
+node .project-management/check-plans.mjs            # done tasks must name a proof and carry evidence
+node .project-management/check-plans.mjs --verify   # also re-run each done task's proof, expect exit 0
+npx planrails check                                 # the same, using the latest published checker
 ```
 
-`task done` runs the gate. If the gate fails, the task stays open and the tool says so. If a condition is unanswered, the tool prints the whole checklist and refuses. That refusal is on purpose: it is the reminder, at the moment it matters, of what "done" means here.
-
-**5. Or let fresh sessions do it.** `npx planrails run weekly-digest --max-tasks 4` starts one `claude -p` session per task. Each starts empty, gets the brief from the hook, does one task, and exits. The driver reads `state.json` to decide what happens next, never the session's words.
-
-**6. Review and close.** `npx planrails review weekly-digest` shows every done task with its gate run and each answered condition. When the plan is done, `npx planrails close weekly-digest --confirmed-by-owner` runs every gate fresh and removes the plan's line from CLAUDE.md. Without the flag it stops and asks you.
-
-## The commands
-
-| command | what it does |
-|---|---|
-| `init`, `update`, `uninstall`, `doctor` | set up, refresh, remove, check |
-| `new <id> --title "…" --paths "src/**"` | scaffold a plan (the `/plan` skill does this for you) |
-| `gate add\|verify\|run\|list <id>` | gates; `verify` proves each can fail |
-| `task add\|check\|start\|done\|block\|unblock\|drop <id> [T]` | the task lifecycle; `done … --answer "C4: …"` runs the gate |
-| `condition list\|add\|drop <id>` | the plan-level conditions of done |
-| `log`, `learn`, `decide` | record progress, a learning, a choice |
-| `brief [id]`, `status <id>`, `review <id> [T]`, `learnings --search x` | read |
-| `validate [--all]` | fail on any plan whose state lies (put it in CI) |
-| `agent-brief <id> <T>` | what a subagent gets instead of the whole plan |
-| `run <id> [--max-tasks N] [--dry-run]` | one fresh session per task |
-| `activate`, `pause`, `close`, `abandon` | plan lifecycle; the last two need `--confirmed-by-owner` |
-| `hooks install\|status\|uninstall\|selftest` | the hooks |
-| `issue [bug\|wish\|edge]` | open a prefilled GitHub issue |
-| `selftest` | prove the validator's refusals can fire |
-
-`npx planrails --help` prints the full list with flags.
-
-## How it survives compaction
+No dependencies. Node 20+, any OS (Windows included). The default is a fast
+structural check: every task that claims to be finished must name a proof and
+carry pasted evidence, and no spelling of "done" can slip past it.
 
-Four layers, cheapest first:
+`--verify` goes further and **runs** each proof again. Because it executes the
+commands written in the plan, use it only on plans you trust — run the default
+structural check in CI that builds untrusted pull requests, and keep `--verify`
+for your own branch or a trusted pipeline.
 
-| when | what the agent gets | size |
-|---|---|---|
-| always | one generated block in CLAUDE.md naming the active plans | a few lines |
-| session start, and after every compaction | a brief rendered from the plan's files: status, the RESUME line, the last log entries, the rules | ≤ 6,000 chars |
-| at a tool call | the rules that match this file or command, once per session | ≤ 1,200 chars each |
-| on demand | everything else, queried with the CLI | not loaded |
+## On a team
 
-Before every compaction a hook writes a journal of what the session did (files written, commands run) to `.planrails/journal/`, and after the compaction another hook hands the path back.
+- **It will not break teammates' builds.** The checker has no dependencies and
+  exits 0 when there are no plans, so a teammate who never uses planrails is
+  unaffected.
+- **The reload line is a plain file include.** `@.project-management/plans/…` in
+  `CLAUDE.md` just tells Claude Code to load that file; it commits like any doc.
+- **Decide whether to commit `.project-management/`.** Committing it shares plans
+  and lets CI run the checker. If your repo gitignores it, the checker still runs
+  locally and the plan still reloads for whoever has the files.
 
-## Done needs evidence, and judgment outranks the gate
+## History
 
-Every task has conditions of done. Three are checked by the tool: the gate passed in this very command, a log entry names the task, the listed files exist. Four are answered in words: the docs shipped, every number has a locator, what was learned is recorded, and you read the result whole and judged it right yourself. A plan can add its own; a task can add its own.
-
-A gate is a script. It cannot read, cannot see, and answers only the question it was written for. So the agent sees the same three lines at every closing moment:
-
-- gate red, work right: never make the gate pass. Write what it computed and what is true. Fix the gate and re-verify it, or block the task for the owner.
-- gate green, work wrong: refuse to close. Say what the gate cannot see.
-- anything crashed: never edit a plan file by hand. Log it, block, stop.
-
-The agent gets no "force pass with a reason" of its own. The override is `task block --needs owner`; the owner's word closes the task. Two rails back this: a gate edited after it was verified cannot close a task until it is verified again, and a gate that was never verified cannot close a task at all.
-
-## Subagents and fresh sessions
-
-`agent-brief <id> <T>` renders what a subagent needs and nothing else: what to do, which files, what done means, where to write its report, what never to do. A subagent never closes a task; the main session verifies the report and closes it. A SubagentStart hook puts the same note in front of every subagent.
-
-`run <id>` is the answer to "clear the context after every task". Claude Code cannot compact or clear on command, so planrails starts a new session per task instead. Each session's only memory of the work is the plan's files.
-
-## Updating, disabling, removing
-
-- `npm install planrails@latest && npx planrails update` refreshes the guide, the skill and the hook entries. Plans are never touched.
-- To turn one hook off, delete its entry from `.claude/settings.json`. `npx planrails doctor` will say it is missing; that is fine.
-- `npx planrails uninstall` removes the hooks and the skill. `npm uninstall planrails` removes the package. The plans, the guide and the CLAUDE.md section stay, so nothing you wrote is lost.
-
-## Reporting a problem, an edge case, or a wish
-
-From any project that uses planrails:
-
-```bash
-npx planrails issue bug     # something broke or refused wrongly
-npx planrails issue edge    # a gate, rule or condition was wrong in a case we did not think of
-npx planrails issue wish    # something you wish it did
-```
-
-It opens a GitHub issue with the environment filled in: versions, platform, what `doctor` and `validate` say. No file contents and no plan text leave your machine. Add `--print` to get the URL instead, or `--gh` to file it with the GitHub CLI.
-
-## Development
-
-```bash
-git clone https://github.com/vivmagarwal/planrails && cd planrails && npm install
-npm test            # the CLI, init, the hooks, the issue command — all against throwaway directories
-npm run selftest    # every refusal in the validator can fire; the hooks on payloads captured from a real run
-npm run acceptance  # needs the claude CLI: a real session must quote the injected brief
-```
+Version 0.1.x was a heavier npm package with a full CLI and installed hooks. A
+review found ten data-loss and silent-failure paths in that surface, and the
+"works with any project" promise broke on pnpm, bun, non-Node projects,
+monorepos and Windows. 0.2.0 keeps the idea and drops the weight: the same three
+rails, as a prompt plus one checker, with a two-command CLI that only copies
+files. See [`CHANGELOG.md`](CHANGELOG.md).
 
-See CONTRIBUTING.md. MIT licensed.
+MIT.

package/bin/planrails.mjs

@@ -1,7 +1,92 @@
 #!/usr/bin/env node
-// The `planrails` command. Everything is dispatched by src/plan/plan.mjs.
+/**
+ * planrails — a planner prompt and one checker. Two commands, both safe:
+ *
+ *   npx planrails init [--dir DIR] [--force]
+ *       Copies PLANNER.md and the checker into <project>/.project-management/ and
+ *       makes the plans/ folder. It writes nothing else — no package.json, no npm
+ *       install, no hooks, no edits to your CLAUDE.md. Idempotent: it skips files
+ *       that already exist unless you pass --force.
+ *
+ *   npx planrails check [--dir DIR] [--verify]
+ *       Runs the checker over the project's plans. --verify re-runs each done
+ *       task's proof. Same as running the copied .project-management/check-plans.mjs.
+ *
+ *   planrails --version | --help
+ */
+import { readFileSync, copyFileSync, mkdirSync, existsSync, writeFileSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolve, dirname } from "node:path";
-const plan = resolve(dirname(fileURLToPath(import.meta.url)), "..", "src", "plan", "plan.mjs");
-process.argv[1] = plan;
-await import(plan);
+import { checkPlans } from "../tools/check-plans.mjs";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const version = () => JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8")).version;
+
+const HELP = `planrails ${version()} — a planner prompt and one checker.
+
+  npx planrails init [--dir DIR] [--force]   set a project up (copies 2 files, writes nothing else)
+  npx planrails check [--dir DIR] [--verify] check the project's plans
+  planrails --version | --help
+
+After init, tell your agent:  Follow .project-management/PLANNER.md and plan <the feature> with me.
+Add to the command you run before every commit:  node .project-management/check-plans.mjs
+Full guide: https://github.com/vivmagarwal/planrails#readme`;
+
+function flag(args, name) {
+  const eq = args.find((a) => a.startsWith(`${name}=`));
+  if (eq) return eq.slice(name.length + 1);
+  const i = args.indexOf(name);
+  return i !== -1 && args[i + 1] && !args[i + 1].startsWith("--") ? args[i + 1] : null;
+}
+
+function init(args) {
+  const target = resolve(flag(args, "--dir") || ".");
+  const force = args.includes("--force");
+  const pm = join(target, ".project-management");
+  const plans = join(pm, "plans");
+  mkdirSync(plans, { recursive: true });
+
+  const copy = (from, to, label) => {
+    if (existsSync(to) && !force) { console.log(`  · ${label} already present (use --force to overwrite)`); return; }
+    copyFileSync(from, to);
+    console.log(`  + ${label}`);
+  };
+  console.log(`planrails ${version()} → ${target}`);
+  copy(join(ROOT, "PLANNER.md"), join(pm, "PLANNER.md"), ".project-management/PLANNER.md");
+  copy(join(ROOT, "tools", "check-plans.mjs"), join(pm, "check-plans.mjs"), ".project-management/check-plans.mjs");
+  const keep = join(plans, ".gitkeep");
+  if (!existsSync(keep)) { writeFileSync(keep, ""); console.log("  + .project-management/plans/"); }
+  else console.log("  · .project-management/plans/ already present");
+
+  console.log(`
+Next:
+  1. Tell your agent:  Follow .project-management/PLANNER.md and plan <the feature> with me.
+     (Or, in Claude Code, use /plan if you installed the skill.)
+  2. Add to the command you run before every commit:
+       node .project-management/check-plans.mjs
+  3. When the agent writes a plan, it adds one line to your CLAUDE.md so the plan
+     reloads after every compaction:  @.project-management/plans/<id>/PLAN.md`);
+  return 0;
+}
+
+function check(args) {
+  const root = resolve(flag(args, "--dir") || ".");
+  if (!existsSync(root)) { console.error(`planrails check: --dir path does not exist: ${root}`); return 2; }
+  const verify = args.includes("--verify");
+  const { plans, problems } = checkPlans({ root, verify });
+  if (!plans.length && !problems.length) { console.log("check-plans: no plans under .project-management/plans/ — nothing to check"); return 0; }
+  if (problems.length) {
+    console.error(`check-plans: ${problems.length} problem(s):\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+    return 1;
+  }
+  console.log(`check-plans: ${plans.length} plan(s) ok — every completion claim has a proof and pasted evidence${verify ? " (proofs re-run)" : ""}`);
+  return 0;
+}
+
+const [cmd, ...args] = process.argv.slice(2);
+if (cmd === "--version" || cmd === "-v") { console.log(version()); process.exit(0); }
+if (!cmd || cmd === "--help" || cmd === "-h") { console.log(HELP); process.exit(cmd ? 0 : 1); }
+if (cmd === "init") process.exit(init(args));
+if (cmd === "check") process.exit(check(args));
+console.error(`planrails: unknown command "${cmd}"\n\n${HELP}`);
+process.exit(2);

package/package.json

@@ -1,53 +1,19 @@
 {
   "name": "planrails",
-  "version": "0.1.2",
-  "description": "Plans that survive compaction, for Claude Code: gates that prove a task done, conditions answered before it closes, briefs and rules injected by hooks, one fresh session per task.",
+  "version": "0.2.0",
+  "description": "Plans that survive a lost session, and \"done\" that means done. A planner prompt and a tiny checker.",
   "type": "module",
-  "bin": {
-    "planrails": "bin/planrails.mjs"
-  },
-  "files": [
-    "bin",
-    "src",
-    "docs/PLANNING_GUIDE.md",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
-  ],
-  "engines": {
-    "node": ">=20.10"
-  },
-  "scripts": {
-    "test": "node scripts/run-tests.mjs",
-    "selftest": "node bin/planrails.mjs selftest && node src/hooks/selftest.mjs",
-    "acceptance": "node scripts/acceptance.mjs",
-    "trial": "node scripts/trial/run.mjs",
-    "prepack": "npm test",
-    "prepublishOnly": "node scripts/release-check.mjs before",
-    "postpublish": "node scripts/release-check.mjs after"
-  },
-  "dependencies": {
-    "zod": "^4.4.3"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vivmagarwal/planrails.git"
-  },
-  "bugs": {
-    "url": "https://github.com/vivmagarwal/planrails/issues"
-  },
+  "license": "MIT",
+  "bin": { "planrails": "bin/planrails.mjs" },
+  "files": ["bin/planrails.mjs", "PLANNER.md", "tools/check-plans.mjs", "README.md", "LICENSE", "CHANGELOG.md"],
+  "repository": { "type": "git", "url": "git+https://github.com/vivmagarwal/planrails.git" },
   "homepage": "https://github.com/vivmagarwal/planrails#readme",
-  "keywords": [
-    "claude-code",
-    "claude",
-    "agent",
-    "planning",
-    "hooks",
-    "compaction",
-    "gates",
-    "project-management",
-    "ai-agents"
-  ],
-  "author": "vivmagarwal",
-  "license": "MIT"
+  "bugs": { "url": "https://github.com/vivmagarwal/planrails/issues" },
+  "keywords": ["planning", "claude-code", "agents", "llm", "compaction", "tracker"],
+  "engines": { "node": ">=20" },
+  "scripts": {
+    "test": "node --test tools/check-plans.test.mjs bin/planrails.test.mjs",
+    "check": "node bin/planrails.mjs check --dir examples/weekly-digest && npm test",
+    "prepublishOnly": "npm test"
+  }
 }