@tekyzinc/gsd-t 5.9.10 → 5.10.11

package/commands/gsd-t-setup.md

@@ -72,109 +72,133 @@ CLAUDE.md Analysis:
 
 Note: "No existing CLAUDE.md — will generate from scratch."
 
-## Step 4: Ask Targeted Questions
+## Step 3.5: Read what actually happened here
 
-Only ask what could NOT be auto-detected. Skip questions where the answer is already clear from scanning.
+Before writing anything, read the project's own history. A rule that keeps
+getting broken is the rule that most needs writing down, and nobody remembers
+those on request — they have to be found.
 
-**Potential questions** (ask only if not auto-detected):
+```bash
+node bin/gsd-t-project-history.cjs --project . --json
+```
 
-1. **Branch Guard**: "Which branch should commits target?" (skip if only `main` or `master` exists)
-2. **Autonomy Level**: "What autonomy level? Level 1 (Supervised), Level 2 (Standard), Level 3 (Full Auto — default)" (skip if existing CLAUDE.md already declares it)
-3. **Workflow Preferences**: "Any overrides to the global defaults? (Research Policy, Phase Flow)" (skip if user has no overrides)
-4. **Deployed URLs**: "Production, staging, and local URLs?" (skip if found in .env or existing docs)
-5. **Project-specific rules**: "Any 'never do' rules specific to this project?" (skip if existing CLAUDE.md already has them)
+Three sources, cheapest first. Each reports whether it was there; a missing one
+is **named**, never skipped in silence:
 
-**Do NOT ask about**:
-- Tech stack (auto-detected)
-- Naming conventions (auto-detected)
-- Testing framework (auto-detected)
-- File structure (auto-detected)
-- Anything already covered by the global CLAUDE.md
+| Source | What it gives |
+|---|---|
+| Git | Files fixed the same way repeatedly, and real reverts |
+| Decision log | Directives already recorded, with dates |
+| Past sessions | What the user typed when something kept going wrong |
 
-## Step 5: Generate CLAUDE.md
+Session history is large — one project holds 315 MB — so the tool funnels it:
+keep only the user's own turns, drop pasted logs, keep only complaint-shaped
+lines. Under a second, and the result fits in context.
 
-Build the file using this structure. Include only sections that have real content — omit empty sections entirely.
+**If it exits 4, there is no history at all.** Do not carry on and write a
+thinner file. Stop and ask:
 
-```markdown
-# {Project Name}
+```
+Sources found: git 67 commits | decision log 1 line | sessions 0 | contracts 0
 
-## Branch Guard
-**Expected branch**: {branch}
+I can mine 0 rules from this project's history.
 
-## Project Overview
-{Brief description — what problem does this solve and for whom?}
+  a) Write stack and commands only — the rules section left out, with the
+     reason written into the file. Not a normal CLAUDE.md.
+  b) You dictate the rules now.
+  c) Stop.
+```
 
-### Architecture
-{High-level architecture summary if the project has one — e.g., "Three-tier WebSocket bridge" with a diagram. Keep it concise. Details belong in docs/architecture.md}
+Whichever they pick, the gap goes **into the generated file** — "Rules: none
+derivable, no project history" — so thinness stays visible rather than reading
+as "this project has no rules."
 
-## Where Things Live
+## Step 4: Show the rules found, and let the user tick them
 
-| Need to find... | Look here |
-|-----------------|-----------|
-| {component} | {path} |
+Do **not** ask the user to recall rules. Mine every rule the project already
+states, and let them confirm:
 
-## Key Technologies
-{Bulleted list of language, framework, database, testing, etc.}
+```bash
+node bin/gsd-t-rule-mine.cjs --project . --top 12
+```
 
-## Documentation
-- Requirements: docs/requirements.md
-- Architecture: docs/architecture.md
-- Workflows: docs/workflows.md
-- Infrastructure: docs/infrastructure.md
+Six sources, ranked by how many agree — a rule found in three places ranks top,
+because repetition is the evidence. The output is a tick-list:
 
-## Autonomy Level
-**Level {N} — {Name}** ({description})  <!-- default: Level 3 — Full Auto -->
+```
+12 candidate rules for binvoice. Tick the ones that must NEVER be broken.
 
-## Workflow Preferences
-<!-- Override global defaults. Delete what you don't need to override. -->
+     RULE                                                    SEEN IN
+ 1 [ ] NEVER contact the buyer directly                      CLAUDE.md (HC-003)
+ 2 [ ] TEXT-FIRST capture (enforced by a pre-write gate)     CLAUDE.md (HC-004)
+ 3 [ ] NEVER scan the whole page                             CLAUDE.md (HC-005)
 
-### Research Policy
-{project-specific overrides, or omit section}
+Tick numbers (e.g. 1,3,4) or 'all':
+```
 
-### Phase Flow
-{project-specific overrides, or omit section}
+The right-hand column is what makes this fast — the user is confirming
+something they already said, not recalling it. **Cap the screen at 12.**
+Anything below goes to `.gsd-t/setup-rules-full.md`; nothing is dropped.
 
-## Testing
-{Framework, file organization, naming, running instructions}
+**Never invent a rule.** Every one comes from somewhere in the project, and the
+tick-list shows where. A rule the user did not tick is not inviolable — it may
+still belong elsewhere in the file, but not in that section.
 
-## Code Patterns to Follow
-{Project-specific conventions that differ from or extend global defaults}
+**Determine these by reading, never by asking:**
 
-### Naming Conventions
-{If different from global defaults}
+| | How |
+|---|---|
+| Which branch | `git branch --show-current` |
+| Where the repo misleads | Two version fields disagreeing, a legacy path that still looks live |
+| Which files are dangerous | Fixed 5+ times in the git history |
+| Stack, build, test | The manifest |
 
-## Running the App
-{Dev server, build commands, first-time setup}
+**Ask only if genuinely unresolvable:** the autonomy level when no existing
+CLAUDE.md declares one, and deployed URLs when nothing records them.
 
-## Environment Variables
-| Variable | Purpose | Default |
-|----------|---------|---------|
-| {VAR} | {purpose} | {default} |
+## Step 5: Generate CLAUDE.md
 
-## Deployed URLs
-- **Production**: {url}
-- **Staging**: {url}
-- **Local**: http://localhost:{port}
+Use the mold at `templates/CLAUDE-project.md`. It is a real mold — do NOT copy
+any existing project's file, and never GSD-T's own.
 
-## Don't Do These Things
-{Project-specific rules only — don't repeat global rules}
+**Every section may be left out, with the reason stated. None may be padded.**
 
-## GSD-T Workflow
-This project uses contract-driven development.
-- State: .gsd-t/progress.md
-- Contracts: .gsd-t/contracts/
-- Domains: .gsd-t/domains/
+| Section | Include when | Fill from |
+|---|---|---|
+| Title + one-line what-this-is | Always | The manifest, the README |
+| **Rules that can never be broken** | The user ticked at least one | Step 4's tick-list, verbatim |
+| Where the repo misleads you | Reading the code gives a confident wrong answer | Determined, never asked |
+| Files riskier than they look | Some file was fixed 5+ times | Git history |
+| Where this differs from global | A genuine difference exists | Compared against `~/.claude/CLAUDE.md` |
+| Stack and commands | Always | The manifest |
+| Where things are written down | Always | Fixed pointers |
 
-## Current Status
-See `.gsd-t/progress.md` for current milestone/phase state.
-```
+**Target 40–70 lines.** If it is longer, something in it is either restating a
+global rule or repeating what the repo already says.
+
+### What must never appear
 
-### Section Rules:
-- **NEVER duplicate** global CLAUDE.md content (Destructive Action Guard, Pre-Commit Gate, Prime Directives, etc.)
-- **ALWAYS include**: Branch Guard, GSD-T Workflow, Current Status
-- **Include if relevant**: Where Things Live, Testing, Code Patterns, Environment Variables
-- **Omit if empty**: Deployed URLs (if not deployed), Architecture (if trivial), Workflow Preferences (if no overrides)
+| Never | Why |
+|---|---|
+| Anything the global file already says | Three projects each paste the entire Destructive Action Guard verbatim — 15 wasted lines apiece |
+| Anything a hook or gate enforces | The machine does not read this file |
+| A version number, a line count, "currently in progress" | Wrong within a week. It belongs in `progress.md` |
+| A file listing, a dependency list, a command count | The repo answers it, and answers it currently |
+| A rule nobody stated | Every rule comes from the tick-list, and the tick-list shows its source |
 
+### The line that matters most
+
+A rule states **what must never happen and what breaks if it does**. If it is
+enforced by a hook or a gate, say so — the reader should know a machine is
+watching:
+
+```
+- **Never touch facebook.com** — no permissions, no requests, no DOM writes.
+  A single write turns a read-only observer into an actor on someone else's
+  account. Enforced by a pre-write gate.
+```
+
+Not: *"Be careful with Facebook interactions."*
 ## Step 5.5: Quality North Star Configuration
 
 After generating the CLAUDE.md content (Step 5) and before presenting it to the user, offer a Quality North Star section if one is not already present.
@@ -275,6 +299,16 @@ Wait for user confirmation before writing.
 2. Verify it's valid markdown (no broken tables, unclosed code blocks)
 3. If `.gsd-t/progress.md` exists, log the setup in the Decision Log
 
+## Step 7.5: Update CLAUDE.md Changelog (M110)
+
+After writing the project CLAUDE.md, update the changelog:
+
+```bash
+node bin/gsd-t-claude-md-changelog.cjs append . rewritten "Generated via /gsd-t-setup"
+```
+
+If the changelog file doesn't exist, the command scaffolds it first.
+
 ## Document Ripple
 
 ### Always update:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.9.10",
+  "version": "5.10.11",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/scripts/gsd-t-changelog-check.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * gsd-t-changelog-check.js
+ *
+ * SessionStart hook: checks if CLAUDE.md was modified outside GSD-T since the
+ * last tracked changelog entry. If so, appends an "External update detected" entry.
+ *
+ * Runs once at session start, not on every prompt.
+ * Exit codes:
+ *   0 — success (up to date, or external update logged)
+ *   1 — not a GSD-T project (no .gsd-t/), or no CLI found — silent skip, not an error
+ *   2 — changelog CLI failed unexpectedly
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+function findCli() {
+  const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+  const globalCli = path.join(globalRoot, '@tekyzinc', 'gsd-t', 'bin', 'gsd-t-claude-md-changelog.cjs');
+  if (fs.existsSync(globalCli)) return globalCli;
+
+  const localCli = path.join(process.cwd(), 'bin', 'gsd-t-claude-md-changelog.cjs');
+  if (fs.existsSync(localCli)) return localCli;
+
+  return null;
+}
+
+function main() {
+  const cwd = process.cwd();
+
+  // Only run in GSD-T projects — silent exit if not
+  if (!fs.existsSync(path.join(cwd, '.gsd-t'))) {
+    process.exit(0);
+  }
+
+  const cli = findCli();
+  if (!cli) {
+    // CLI not installed — silent exit (GSD-T may not be fully set up yet)
+    process.exit(0);
+  }
+
+  let checkResult;
+  try {
+    checkResult = execSync(`node "${cli}" check-external "${cwd}"`, { encoding: 'utf8' });
+    // Exit code 0 = up to date
+    process.exit(0);
+  } catch (e) {
+    if (e.status === 1) {
+      // External update detected — append entry
+      execSync(`node "${cli}" append "${cwd}" external`, { encoding: 'utf8' });
+      process.stdout.write('CLAUDE.md changelog: external update detected and logged.\n');
+      process.exit(0);
+    }
+    if (e.status === 2) {
+      // Corrupt changelog — report but don't block session
+      process.stderr.write('CLAUDE.md changelog is corrupt. Run: node bin/gsd-t-claude-md-changelog.cjs get-last-entry-time .\n');
+      process.exit(0);
+    }
+    // Unexpected error — report it
+    process.stderr.write('CLAUDE.md changelog check failed: ' + (e.message || 'unknown error') + '\n');
+    process.exit(2);
+  }
+}
+
+main();

package/scripts/gsd-t-changelog-post-edit.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * gsd-t-changelog-post-edit.js
+ *
+ * PostToolUse hook for Write|Edit: after a successful write to CLAUDE.md,
+ * reminds Claude to update the changelog.
+ *
+ * Receives JSON on stdin with tool_input containing file_path.
+ * Outputs reminder text to stdout if the target was CLAUDE.md.
+ *
+ * Does NOT auto-append — Claude should consciously decide what changed and
+ * call the append command with appropriate bullets.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+
+  // Get the file path from tool_input
+  const toolInput = data.tool_input;
+  if (!toolInput) {
+    process.exit(0);
+  }
+
+  let filePath;
+  if (typeof toolInput === 'string') {
+    try {
+      const parsed = JSON.parse(toolInput);
+      filePath = parsed.file_path;
+    } catch {
+      process.exit(0);
+    }
+  } else if (typeof toolInput === 'object') {
+    filePath = toolInput.file_path;
+  }
+
+  if (!filePath) {
+    process.exit(0);
+  }
+
+  // Check if it's CLAUDE.md (root or .claude/)
+  const basename = path.basename(filePath);
+  if (basename !== 'CLAUDE.md') {
+    process.exit(0);
+  }
+
+  // Check if it's NOT the global ~/.claude/CLAUDE.md (only track project CLAUDE.md)
+  const homeClaudeMd = path.join(process.env.HOME || '', '.claude', 'CLAUDE.md');
+  if (path.resolve(filePath) === path.resolve(homeClaudeMd)) {
+    process.exit(0);
+  }
+
+  // It's a project CLAUDE.md — remind to update changelog
+  const projectDir = data.cwd || process.cwd();
+  const changelogPath = path.join(projectDir, 'CLAUDE.md updates.md');
+
+  process.stdout.write(
+    `[M110] You just modified CLAUDE.md. Update the changelog:\n` +
+    `  node bin/gsd-t-claude-md-changelog.cjs append "${projectDir}" updated "" '["<describe what changed>"]'\n`
+  );
+
+  process.exit(0);
+});

package/templates/CLAUDE-project.md

@@ -1,127 +1,70 @@
-# GSD-T Framework (@tekyzinc/gsd-t)
+# {PROJECT_NAME}
 
-Prime Directives, core guards, and workflow rules live in `~/.claude/CLAUDE.md`. This file covers what's specific to this repo.
+{ONE_LINE_WHAT_THIS_IS}
 
-## Overview
+> Everything general lives in `~/.claude/CLAUDE.md` and applies here. This file
+> holds only what is true of this project and nothing else.
 
-Contract-driven development methodology for Claude Code. npm package providing slash commands, a CLI installer, templates, and stack rules for reliable parallelizable AI-assisted development.
+## Rules that can never be broken
 
-## Autonomy Level
+<!--
+  Ticked by David from what the project already says. Nothing invented, nothing
+  copied from the global file. If a rule is enforced by a hook or a gate, say so
+  — the reader should know a machine is watching.
 
-> Overrides global: pins the default from `~/.claude/CLAUDE.md` § Autonomy Levels.
+  Leave this section out entirely if none were found, and say why.
+-->
+{RULES}
 
-**Level 3 — Full Auto**. Only pause for blockers, destructive actions, or project completion.
+## Where the repo misleads you
 
-## Tech Stack
+<!--
+  Only where reading the code gives a confident WRONG answer — two version
+  fields disagreeing, a legacy path that still looks live, a config that is not
+  the one in use. Leave out if none.
+-->
+{MISLEADS}
 
-- **Language**: JavaScript (Node.js >= 16), zero external runtime deps for the installer
-- **Distribution**: npm package `@tekyzinc/gsd-t`
-- **CLI**: `bin/gsd-t.js` (install, update, init, status, uninstall, doctor, graph, headless, …)
-- **Testing**: `npm test` (Node built-in test runner) + manual CLI testing
+## Files that are riskier than they look
 
-## Project Structure
+<!--
+  Determined by reading, never asked. A file fixed the same way five times is a
+  rule nobody wrote down. Say what breaks, not just which file. Leave out if none.
+-->
+{DANGER_MAP}
 
-```
-bin/                     — CLI entry (gsd-t.js) + orchestrators (orchestrator.js, design-orchestrator.js)
-                           + support modules (gsd-t-context-brief.cjs, cli-preflight.cjs, gsd-t-verify-gate.cjs, gsd-t-model-tier-policy.cjs, …)
-commands/                — slash commands for Claude Code (GSD-T workflow + utility)
-templates/               — document + prompt + stack templates
-  CLAUDE-{global,project}.md, requirements.md, architecture.md, workflows.md,
-  infrastructure.md, progress.md, backlog.md, backlog-settings.md, design-contract.md
-  prompts/               — validation subagent protocols (qa, red-team, design-verify)
-  stacks/                — Stack Rules Engine templates (injected at spawn time)
-scripts/                 — runtime scripts (design review, context meter hook, event writer)
-examples/                — example project structure + settings
-docs/methodology.md      — GSD → GSD-T evolution and concepts
-package.json, README.md, GSD-T-README.md, CHANGELOG.md
-```
+## Where this differs from the global rules
 
-Exact command list: `ls commands/`. Exact stack rule set: `ls templates/stacks/`. Don't hand-maintain counts in docs.
+<!-- ONLY genuine differences. An empty table means there are none — leave it out. -->
 
-## Meta-Project Notes
+| Global default | Here | Why |
+|---|---|---|
+{OVERRIDES}
 
-- The "source" is the `.md` files in `commands/` + `templates/` and the JS in `bin/` + `scripts/`. There is no `src/`.
-- Changes to command files change the methodology itself — treat them as code; verify by running the workflow.
-- The `.gsd-t/` state dir coexists with the commands that *define* `.gsd-t/` — intentional.
-- `bin/gsd-t.js` is the primary testable surface; command files are validated by use.
+## Stack and commands
 
-## Conventions
+{STACK}
 
-**CLI** — ANSI colors via escape codes, zero external deps, sync file APIs, version tracked in `package.json` and `~/.claude/.gsd-t-version`.
+| | |
+|---|---|
+| Build | `{BUILD_CMD}` |
+| Test | `{TEST_CMD}` |
+| Branch | `{BRANCH}` |
 
-**Command files** — pure markdown, no frontmatter, accept `$ARGUMENTS`, step-numbered, thin Workflow invokers (`Workflow({scriptPath, args})`). Include a Document Ripple section listing files the underlying Workflow expects domain workers to update. Validation protocol bodies stay in `templates/prompts/*-subagent.md`; Workflow scripts load them via `_lib.loadProtocol(name)`. Don't inline the protocol.
+## Where things are written down
 
-**Templates** — `{Project Name}`, `{Date}`, `{description}` replacement tokens; tables for structured data.
+| | |
+|---|---|
+| State and decisions | `.gsd-t/progress.md` |
+| Interfaces between parts | `.gsd-t/contracts/` |
+| How to reach environments | `docs/infrastructure.md` |
 
-**Directory structure** — `.gsd-t/contracts/` (domain interfaces), `.gsd-t/domains/{name}/` (scope/tasks/constraints), `.gsd-t/milestones/` (archives), `.gsd-t/scan/` (analysis outputs).
+<!--
+  Written {GENERATED_DATE} from this project's own history.
 
-**Publishing** — after `npm publish`, ALWAYS run `/gsd-t-version-update-all` to propagate to registered projects.
+  Nothing above should carry a number that changes on its own — no version, no
+  line count, no "currently in progress". Those belong in progress.md, and a
+  file that repeats them is wrong within a week.
 
-## GSD-T Workflows (M61 — v4.0.10+)
-
-Phase orchestration lives in `templates/workflows/`. Each command file (`commands/gsd-t-*.md`) is a thin invoker that calls `Workflow({scriptPath, args})`. Canonical scripts:
-
-- `gsd-t-execute.workflow.js` — preflight → brief → file-disjointness → parallel(domain workers) → integrate → verify-gate
-- `gsd-t-verify.workflow.js` — orthogonal triad with M57 CI-parity + M58 test-data purge as FAIL-blocking gates
-- `gsd-t-wave.workflow.js`, `-integrate`, `-debug`, `-quick`, `-phase` (generic upper-stage runner)
-
-Shared helpers: `templates/workflows/_lib.js`. Each helper prefers project-local `bin/<tool>.cjs` and falls back to global `gsd-t` PATH binary.
-
-The brains stay in `bin/`: `gsd-t-file-disjointness.cjs`, `gsd-t-task-graph.cjs`, `gsd-t-context-brief.cjs`, `cli-preflight.cjs`, `gsd-t-verify-gate.cjs`, `gsd-t-verify-gate-judge.cjs`, `gsd-t-build-coverage.cjs`, `gsd-t-ci-parity.cjs`, `gsd-t-test-data-ledger.cjs`, `journey-coverage.cjs`. Workflows invoke them via `lib.*` helpers.
-
-## Validation Protocols (KEPT — methodology layer)
-
-Three validation protocol bodies stay at `templates/prompts/`:
-- `qa-subagent.md` — test mechanics + shallow-test detection + contract compliance
-- `red-team-subagent.md` — adversarial / security / boundaries; verdict `FAIL` / `GRUDGING-PASS`
-- `design-verify-subagent.md` — visual MATCH/DEVIATION against the design contract
-
-These are invoked as Workflow `agent()` stages with schema-validated output. The methodology body is unchanged; only the invocation context (Workflow stage vs. Task subagent) updated. Per `.gsd-t/contracts/orthogonal-validation-contract.md` v1.0.0 STABLE.
-
-
-# Destructive Action Guard (MANDATORY)
-
-**NEVER perform destructive or structural changes without explicit user approval.** This applies at ALL autonomy levels.
-
-Before any of these actions, STOP and ask the user:
-- DROP TABLE, DROP COLUMN, DROP INDEX, TRUNCATE, DELETE without WHERE
-- Renaming or removing database tables or columns
-- Schema migrations that lose data or break existing queries
-- Replacing an existing architecture pattern (e.g., normalized → denormalized)
-- Removing or replacing existing files/modules that contain working functionality
-- Changing ORM models in ways that conflict with the existing database schema
-- Removing API endpoints or changing response shapes that existing clients depend on
-- Any change that would require other parts of the system to be rewritten
-
-**Rule: "Adapt new code to existing structures, not the other way around."**
-
-## Pre-Commit Gate (project-specific additions)
-
-The global gate applies first (see `~/.claude/CLAUDE.md`). Additionally for this repo:
-
-- **Command file interface/behavior changed** → update `GSD-T-README.md` + `README.md` commands table + `templates/CLAUDE-global.md` + `commands/gsd-t-help.md`.
-- **Command added/removed** → update all 4 files above, bump `package.json`, update any command-counting logic in `bin/gsd-t.js`.
-- **New command invokes a Workflow** → verify `scriptPath` resolves to `templates/workflows/<name>.workflow.js` and `args` shape matches the script's `meta.phases`.
-- **CLI installer changed** → smoke test `install`, `update`, `status`, `doctor`, `init`, `uninstall`.
-- **Template changed** → verify `gsd-t-init` still produces correct output.
-- **Wave flow changed (phases added/removed/reordered)** → update `gsd-t-wave.md`, `GSD-T-README.md` wave diagram, `README.md` workflow section.
-- **Contract or domain boundary changed** → update `.gsd-t/contracts/` and owning `scope.md`.
-
-## Don't
-
-- NEVER add external npm runtime dependencies to the installer — zero-dep invariant.
-- NEVER rename a command without updating all 4 reference files above.
-- NEVER modify wave phase sequence without updating wave, README, GSD-T-README in the same commit.
-- NEVER let installer's command count diverge from `commands/` directory reality.
-- NEVER inline validation-subagent protocol bodies into Workflow scripts — `_lib.loadProtocol("qa"|"red-team"|"design-verify")` reads the methodology body from `templates/prompts/`.
-
-## Recovery After Interruption
-
-1. Read `.gsd-t/progress.md`
-2. Read `README.md` for what the package delivers
-3. Check `commands/` and `package.json` for current state
-4. Continue from current task; don't restart the phase
-
-## Current Status
-
-See `.gsd-t/progress.md`.
+  Regenerate with /gsd-t-setup.
+-->