@tekyzinc/gsd-t 2.50.12 → 2.53.10

package/commands/gsd-t-reflect.md

@@ -1,134 +1,134 @@
-# GSD-T: Reflect — Generate Retrospective from Event Stream
-
-You are generating a structured retrospective for the current (or specified) milestone by reading the JSONL event stream and proposing memory updates.
-
-## Step 0: Launch via Subagent
-
-When invoked directly by the user, spawn yourself as a Task subagent for a fresh context window.
-
-**OBSERVABILITY LOGGING — before spawning:**
-
-Run via Bash:
-`T_START=$(date +%s) && DT_START=$(date +"%Y-%m-%d %H:%M") && TOK_START=${CLAUDE_CONTEXT_TOKENS_USED:-0} && TOK_MAX=${CLAUDE_CONTEXT_TOKENS_MAX:-200000}`
-
-```
-Task subagent (general-purpose, model: sonnet):
-"Run the GSD-T reflect command. Read commands/gsd-t-reflect.md for your full instructions.
-Arguments: {$ARGUMENTS}
-Skip Step 0 — you are already the subagent."
-```
-
-**OBSERVABILITY LOGGING — after subagent returns:**
-
-Run via Bash:
-`T_END=$(date +%s) && DT_END=$(date +"%Y-%m-%d %H:%M") && TOK_END=${CLAUDE_CONTEXT_TOKENS_USED:-0} && DURATION=$((T_END-T_START))`
-
-Compute tokens:
-- No compaction (TOK_END >= TOK_START): `TOKENS=$((TOK_END-TOK_START))`, COMPACTED=null
-- Compaction detected (TOK_END < TOK_START): `TOKENS=$(((TOK_MAX-TOK_START)+TOK_END))`, COMPACTED=$DT_END
-
-Append to `.gsd-t/token-log.md` (create with header `| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Notes | Tokens | Compacted |` if missing):
-`| {DT_START} | {DT_END} | gsd-t-reflect | Step 0 | sonnet | {DURATION}s | retrospective generated | {TOKENS} | {COMPACTED} |`
-
-Return the subagent's output and stop. Only skip Step 0 if you are already running as a subagent.
-
-## Step 1: Load State
-
-Read:
-1. `CLAUDE.md` — project context
-2. `.gsd-t/progress.md` — current milestone name and start date
-3. `.gsd-t/contracts/event-schema-contract.md` — event fields available for reading
-
-Identify the current milestone name and its start date from the `## Current Milestone` table in `progress.md`.
-
-If `$ARGUMENTS` is provided, treat it as a milestone name filter — search for a past milestone matching that name in the `## Completed Milestones` table and use its completion date as the date boundary instead.
-
-## Step 2: Find Events
-
-Look for `.gsd-t/events/*.jsonl` files.
-
-If no `.gsd-t/events/` directory or no `.jsonl` files exist:
-```
-No events recorded for this milestone yet.
-Events are written during execute/wave/debug phases once the event-writer is installed.
-```
-Stop and exit.
-
-Filter events by milestone period: include only JSONL lines with `"ts"` values on or after the milestone start date (from Step 1). Read all matching `.jsonl` files and collect the event objects.
-
-## Step 3: Generate Retrospective
-
-Parse the collected events and categorize:
-
-**By outcome:**
-- `success` events — commands/phases that completed successfully
-- `failure` events — commands/phases that failed (capture `reasoning` field)
-- `learning` events — insights captured during execution (capture `reasoning`)
-- `deferred` events — items postponed (capture `reasoning`)
-
-**Command patterns:**
-- Which `command` values appear most in failure events
-- Which `phase` values appear most in failure events
-
-**Repeating patterns (threshold ≥ 2):**
-- Group events by `reasoning` field value (exact string match)
-- Identify any `reasoning` string that appears in 2 or more events
-
-**Summary:**
-- What worked: `command`/`phase` values that have only `success` outcomes
-- What failed: failure events with their `reasoning` and `command`
-- What was learned: `learning` outcome events and their `reasoning`
-
-## Step 4: Write Retrospective File
-
-Create `.gsd-t/retrospectives/` directory if it does not exist.
-
-Determine the output filename:
-- Current milestone: `{YYYY-MM-DD}-{milestone-name-kebab-case}.md` (today's date)
-- Past milestone (from $ARGUMENTS): use that milestone's completion date
-
-Write the retrospective file:
-
-```markdown
-# Retrospective: {Milestone Name}
-**Generated**: {YYYY-MM-DD}
-**Milestone period**: {start date} → {end date}
-**Events analyzed**: {N}
-
-## What Worked
-{List each command/phase that had only success outcomes — one per line}
-{If none: _No commands with exclusively success outcomes recorded._}
-
-## What Failed
-{For each failure event: `- [{command}] {reasoning}`}
-{If none: _No failure events recorded._}
-
-## Patterns Found
-{For each reasoning string with ≥ 2 occurrences: `- ({N}×) {reasoning}`}
-{If none: _No repeating patterns found (threshold: 2 occurrences)._}
-
-## Proposed Memory Updates
-{For each pattern found: suggest a concrete rule}
-{Format: `- Pattern ({N}×): "{reasoning}" → Rule: "Always/Never {concrete action}"`}
-{If none: _No patterns met the threshold for a proposed rule._}
-```
-
-## Step 5: Present Proposed Memory Updates
-
-For each item in the **Proposed Memory Updates** section:
-
-1. Present to user: `"Proposed rule (seen {N} times): '{rule}'. Add to CLAUDE.md? [y/n]"`
-2. **Wait for user confirmation before writing** (Destructive Action Guard — CLAUDE.md changes require explicit approval)
-3. If approved: append the rule to `CLAUDE.md` under the relevant section
-4. If none to propose: report "No repeating patterns found — no memory updates proposed."
-
-## Document Ripple
-
-Update `.gsd-t/progress.md` Decision Log:
-- Add entry: `- {YYYY-MM-DD HH:MM}: [learning] gsd-t-reflect run — retrospective written to .gsd-t/retrospectives/{filename}.md; {N} events analyzed, {N} patterns found, {N} rules proposed`
-
-$ARGUMENTS
-
-## Auto-Clear
-
-All work is committed to project files. Execute `/clear` to free the context window for the next command.
+# GSD-T: Reflect — Generate Retrospective from Event Stream
+
+You are generating a structured retrospective for the current (or specified) milestone by reading the JSONL event stream and proposing memory updates.
+
+## Step 0: Launch via Subagent
+
+When invoked directly by the user, spawn yourself as a Task subagent for a fresh context window.
+
+**OBSERVABILITY LOGGING — before spawning:**
+
+Run via Bash:
+`T_START=$(date +%s) && DT_START=$(date +"%Y-%m-%d %H:%M") && TOK_START=${CLAUDE_CONTEXT_TOKENS_USED:-0} && TOK_MAX=${CLAUDE_CONTEXT_TOKENS_MAX:-200000}`
+
+```
+Task subagent (general-purpose, model: sonnet):
+"Run the GSD-T reflect command. Read commands/gsd-t-reflect.md for your full instructions.
+Arguments: {$ARGUMENTS}
+Skip Step 0 — you are already the subagent."
+```
+
+**OBSERVABILITY LOGGING — after subagent returns:**
+
+Run via Bash:
+`T_END=$(date +%s) && DT_END=$(date +"%Y-%m-%d %H:%M") && TOK_END=${CLAUDE_CONTEXT_TOKENS_USED:-0} && DURATION=$((T_END-T_START))`
+
+Compute tokens:
+- No compaction (TOK_END >= TOK_START): `TOKENS=$((TOK_END-TOK_START))`, COMPACTED=null
+- Compaction detected (TOK_END < TOK_START): `TOKENS=$(((TOK_MAX-TOK_START)+TOK_END))`, COMPACTED=$DT_END
+
+Append to `.gsd-t/token-log.md` (create with header `| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Notes | Tokens | Compacted |` if missing):
+`| {DT_START} | {DT_END} | gsd-t-reflect | Step 0 | sonnet | {DURATION}s | retrospective generated | {TOKENS} | {COMPACTED} |`
+
+Return the subagent's output and stop. Only skip Step 0 if you are already running as a subagent.
+
+## Step 1: Load State
+
+Read:
+1. `CLAUDE.md` — project context
+2. `.gsd-t/progress.md` — current milestone name and start date
+3. `.gsd-t/contracts/event-schema-contract.md` — event fields available for reading
+
+Identify the current milestone name and its start date from the `## Current Milestone` table in `progress.md`.
+
+If `$ARGUMENTS` is provided, treat it as a milestone name filter — search for a past milestone matching that name in the `## Completed Milestones` table and use its completion date as the date boundary instead.
+
+## Step 2: Find Events
+
+Look for `.gsd-t/events/*.jsonl` files.
+
+If no `.gsd-t/events/` directory or no `.jsonl` files exist:
+```
+No events recorded for this milestone yet.
+Events are written during execute/wave/debug phases once the event-writer is installed.
+```
+Stop and exit.
+
+Filter events by milestone period: include only JSONL lines with `"ts"` values on or after the milestone start date (from Step 1). Read all matching `.jsonl` files and collect the event objects.
+
+## Step 3: Generate Retrospective
+
+Parse the collected events and categorize:
+
+**By outcome:**
+- `success` events — commands/phases that completed successfully
+- `failure` events — commands/phases that failed (capture `reasoning` field)
+- `learning` events — insights captured during execution (capture `reasoning`)
+- `deferred` events — items postponed (capture `reasoning`)
+
+**Command patterns:**
+- Which `command` values appear most in failure events
+- Which `phase` values appear most in failure events
+
+**Repeating patterns (threshold ≥ 2):**
+- Group events by `reasoning` field value (exact string match)
+- Identify any `reasoning` string that appears in 2 or more events
+
+**Summary:**
+- What worked: `command`/`phase` values that have only `success` outcomes
+- What failed: failure events with their `reasoning` and `command`
+- What was learned: `learning` outcome events and their `reasoning`
+
+## Step 4: Write Retrospective File
+
+Create `.gsd-t/retrospectives/` directory if it does not exist.
+
+Determine the output filename:
+- Current milestone: `{YYYY-MM-DD}-{milestone-name-kebab-case}.md` (today's date)
+- Past milestone (from $ARGUMENTS): use that milestone's completion date
+
+Write the retrospective file:
+
+```markdown
+# Retrospective: {Milestone Name}
+**Generated**: {YYYY-MM-DD}
+**Milestone period**: {start date} → {end date}
+**Events analyzed**: {N}
+
+## What Worked
+{List each command/phase that had only success outcomes — one per line}
+{If none: _No commands with exclusively success outcomes recorded._}
+
+## What Failed
+{For each failure event: `- [{command}] {reasoning}`}
+{If none: _No failure events recorded._}
+
+## Patterns Found
+{For each reasoning string with ≥ 2 occurrences: `- ({N}×) {reasoning}`}
+{If none: _No repeating patterns found (threshold: 2 occurrences)._}
+
+## Proposed Memory Updates
+{For each pattern found: suggest a concrete rule}
+{Format: `- Pattern ({N}×): "{reasoning}" → Rule: "Always/Never {concrete action}"`}
+{If none: _No patterns met the threshold for a proposed rule._}
+```
+
+## Step 5: Present Proposed Memory Updates
+
+For each item in the **Proposed Memory Updates** section:
+
+1. Present to user: `"Proposed rule (seen {N} times): '{rule}'. Add to CLAUDE.md? [y/n]"`
+2. **Wait for user confirmation before writing** (Destructive Action Guard — CLAUDE.md changes require explicit approval)
+3. If approved: append the rule to `CLAUDE.md` under the relevant section
+4. If none to propose: report "No repeating patterns found — no memory updates proposed."
+
+## Document Ripple
+
+Update `.gsd-t/progress.md` Decision Log:
+- Add entry: `- {YYYY-MM-DD HH:MM}: [learning] gsd-t-reflect run — retrospective written to .gsd-t/retrospectives/{filename}.md; {N} events analyzed, {N} patterns found, {N} rules proposed`
+
+$ARGUMENTS
+
+## Auto-Clear
+
+All work is committed to project files. Execute `/clear` to free the context window for the next command.

package/commands/gsd-t-resume.md

@@ -1,72 +1,72 @@
-# GSD-T: Resume — Continue From Last State
-
-You are resuming work after an interruption. This handles both same-session pauses (user pressed Esc to interject) and cross-session recovery (new Claude Code session).
-
-## Step 0: Detect Resume Mode
-
-**Same-session** (conversation context still available — you can see prior messages about the active phase/task):
-- Skip to Step 2 — you already have the context loaded
-- Do NOT re-read all state files
-
-**Cross-session** (first command in a new session, no prior conversation context):
-- Run Step 1 to load full state
-
-## Step 1: Load Full State (cross-session only)
-
-Read in this exact order:
-1. `CLAUDE.md` — project context and conventions
-2. **Check for continue-here files first**: List `.gsd-t/continue-here-*.md` files. If any exist, read the most recent one (highest timestamp). It contains exact position, next action, and open items — use this as the primary resume point.
-3. `.gsd-t/progress.md` — current status, decisions, blockers (always read this too)
-4. `.gsd-t/contracts/` — all contract files
-4. `.gsd-t/domains/*/scope.md` — domain boundaries
-5. `.gsd-t/domains/*/tasks.md` — task lists with completion status
-6. `.gsd-t/domains/*/constraints.md` — domain rules
-7. `.gsd-t/contracts/integration-points.md` — dependency graph
-8. `.gsd-t/verify-report.md` (if exists) — verification findings
-
-## Step 2: Determine Current Position
-
-From the continue-here file (if present) OR progress.md (or conversation context if same-session), identify:
-- Current milestone and status
-- Which phase we're in
-- Which tasks are done, in progress, or blocked
-- Any pending decisions or user-input-needed items
-- Last entry in the Decision Log
-
-**If a continue-here file was found**: Use its "Next Action" field as the primary resume point. The continue-here file is more precise than progress.md alone. After resuming, delete the continue-here file (it has been consumed).
-
-## Step 3: Report and Continue
-
-**Level 3 (Full Auto)**: Log a brief status line and auto-resume from the current task/phase. Do NOT wait for user input.
-
-```
-🔄 Resuming: {milestone name} — {phase} — {next task or action}
-```
-
-**Level 1–2**: Present fuller context and wait for confirmation:
-
-```
-🔄 GSD-T Resuming: {milestone name}
-Phase: {current phase}
-Last activity: {last Decision Log entry}
-
-Progress:
-  {domain-1}: {completed}/{total} tasks
-  {domain-2}: {completed}/{total} tasks
-
-Next up: {specific next action}
-Blockers: {any pending items} | None
-
-Ready to continue? Or run /user:gsd-t-status for full details.
-```
-
-## Step 4: Continue
-
-If $ARGUMENTS specifies what to do next, proceed with that.
-Otherwise, pick up from the logical next action based on current state:
-- Mid-execution → Continue with next unblocked task
-- Between phases → Start next phase
-- Blocked → Explain what's needed to unblock
-- Verify failed → Show remediation tasks
-
-$ARGUMENTS
+# GSD-T: Resume — Continue From Last State
+
+You are resuming work after an interruption. This handles both same-session pauses (user pressed Esc to interject) and cross-session recovery (new Claude Code session).
+
+## Step 0: Detect Resume Mode
+
+**Same-session** (conversation context still available — you can see prior messages about the active phase/task):
+- Skip to Step 2 — you already have the context loaded
+- Do NOT re-read all state files
+
+**Cross-session** (first command in a new session, no prior conversation context):
+- Run Step 1 to load full state
+
+## Step 1: Load Full State (cross-session only)
+
+Read in this exact order:
+1. `CLAUDE.md` — project context and conventions
+2. **Check for continue-here files first**: List `.gsd-t/continue-here-*.md` files. If any exist, read the most recent one (highest timestamp). It contains exact position, next action, and open items — use this as the primary resume point.
+3. `.gsd-t/progress.md` — current status, decisions, blockers (always read this too)
+4. `.gsd-t/contracts/` — all contract files
+4. `.gsd-t/domains/*/scope.md` — domain boundaries
+5. `.gsd-t/domains/*/tasks.md` — task lists with completion status
+6. `.gsd-t/domains/*/constraints.md` — domain rules
+7. `.gsd-t/contracts/integration-points.md` — dependency graph
+8. `.gsd-t/verify-report.md` (if exists) — verification findings
+
+## Step 2: Determine Current Position
+
+From the continue-here file (if present) OR progress.md (or conversation context if same-session), identify:
+- Current milestone and status
+- Which phase we're in
+- Which tasks are done, in progress, or blocked
+- Any pending decisions or user-input-needed items
+- Last entry in the Decision Log
+
+**If a continue-here file was found**: Use its "Next Action" field as the primary resume point. The continue-here file is more precise than progress.md alone. After resuming, delete the continue-here file (it has been consumed).
+
+## Step 3: Report and Continue
+
+**Level 3 (Full Auto)**: Log a brief status line and auto-resume from the current task/phase. Do NOT wait for user input.
+
+```
+🔄 Resuming: {milestone name} — {phase} — {next task or action}
+```
+
+**Level 1–2**: Present fuller context and wait for confirmation:
+
+```
+🔄 GSD-T Resuming: {milestone name}
+Phase: {current phase}
+Last activity: {last Decision Log entry}
+
+Progress:
+  {domain-1}: {completed}/{total} tasks
+  {domain-2}: {completed}/{total} tasks
+
+Next up: {specific next action}
+Blockers: {any pending items} | None
+
+Ready to continue? Or run /user:gsd-t-status for full details.
+```
+
+## Step 4: Continue
+
+If $ARGUMENTS specifies what to do next, proceed with that.
+Otherwise, pick up from the logical next action based on current state:
+- Mid-execution → Continue with next unblocked task
+- Between phases → Start next phase
+- Blocked → Explain what's needed to unblock
+- Verify failed → Show remediation tasks
+
+$ARGUMENTS