SMTM v4 Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Upgrade the SMTM project workflow to v4 — adding ROADMAP.md, two-tier project structure, STATUS.md orientation block, phase-scoped NEXT-STEPS.md, task brief format, ROADMAP↔STATUS sync hook, and LESSONS.md review at project closure.

Architecture: Four skill files updated in-place (project-start, project-continue, project-task-complete, task-start), one new skill created (write-task-brief), one sync script + hook added, and SMTM_System.md rewritten to v4. No code or tests — verification is read-back and manual invocation.

Tech Stack: Markdown skill files in ~/.claude/commands/, Python 3 sync script, Claude Code PostToolUse hook in ~/.claude/settings.json, SMTM_System.md documentation.

File Structure

Action	File	Change
Modify	`/home/ta/.claude/commands/project-start.md`	Add ROADMAP.md creation; tier prompt (Simple/Complex); phases/ folder for Complex
Modify	`/home/ta/.claude/commands/project-continue.md`	Read “Current Phase” block first; sync check before acting
Modify	`/home/ta/.claude/commands/project-task-complete.md`	Phase boundary enforcement; NEXT-STEPS.md reset to template; LESSONS.md review step; simple project closure
Modify	`/home/ta/.claude/commands/task-start.md`	No changes needed — task files already have Agent Response section
Create	`/home/ta/.claude/commands/write-task-brief.md`	New skill for external agent task brief creation
Create	`/mnt/d/FSS/Scripts/smtm-roadmap-sync.py`	Sync script: reads ROADMAP.md phases/tasks, updates STATUS.md names (not checkboxes)
Modify	`/home/ta/.claude/settings.json`	Add PostToolUse hook for ROADMAP.md sync
Modify	`/mnt/d/FSS/KB/Business/03_Processes/Simple Markdown Task Management/SMTM_System.md`	Rewrite to v4
Modify	`/home/ta/.claude/projects/-home-ta-projects-monorepo/memory/MEMORY.md`	Remove STATUS.md Feedback references; update project structure notes

Task 1: Update `project-start` skill

Files:

Modify: /home/ta/.claude/commands/project-start.md

Step 1: Read the current file

cat /home/ta/.claude/commands/project-start.md

Step 2: Rewrite the skill

Replace the full file content with:

Start a new project in the KB task management system. The project name may be provided as an argument.

## Steps

0. **Enter plan mode** — Before creating any files, enter plan mode. Gather the project name and determine the tier (Simple or Complex). Present the proposed structure for user approval before creating files.

1. **Get project name and tier**
   - Name: use argument if provided, otherwise ask
   - Tier: ask "Simple project (<10 tasks, single phase) or Complex (multiple phases)?"

2. **Create project folder** at `/mnt/d/FSS/KB/Business/_WorkingOn/Projects/[name]/`

   **Simple tier:**

Projects/[name]/ ├── ROADMAP.md ← task list + goal ├── STATUS.md ← state only ├── NEXT-STEPS.md ← Claude/Talbot dialogue ├── LESSONS.md ├── logs/ └── archive/

**Complex tier** (adds phases/):

Projects/[name]/ ├── ROADMAP.md ← multi-phase TOC ├── phases/ │ └── Phase-1-[name]/ ← create first phase folder ├── STATUS.md ├── NEXT-STEPS.md ├── LESSONS.md ├── logs/ └── archive/

3. **Create ROADMAP.md**

Simple:
```markdown
# [Project Name] — Roadmap

**Goal:** [one sentence]
**Type:** Simple

---

## Tasks
- Task-1: [description]
- Task-2: [description]

## Future / Backlog

Complex:

# [Project Name] — Roadmap

**Goal:** [one sentence]
**Type:** Complex
**Description:** [optional 2-3 sentences]

---

## Phase 1 — [Name]
- Task-1: [description]
- Task-2: [description]

## Phase 2 — [Name]
- Task-1: [description]

## Future / Backlog

Create STATUS.md (state only — no Key Decisions, no Feedback):

# [Project Name] — Status

**Last Updated:** YYYY-MM-DD

## Current Phase
**Phase:** 1 — [Phase Name]
**Active tasks:** Task-1-[descrip]  *(list all tasks currently in flight)*
**Last action:** Project created (YYYY-MM-DD)
**Next:** [first task or decision]

*(For Simple projects, "Active tasks" lists task names directly. For Complex, include phase subfolder prefix if helpful: `Phase-1/Task-2-[descrip]`.)*

---

## Phase 1 — [Name] 🟡 (Active)
- [ ] Task-1: [description]
- [ ] Task-2: [description]

Note: STATUS.md phase/task names must mirror ROADMAP.md exactly. Only checkboxes are edited by Claude/Talbot — names are synced by the ROADMAP hook.

Create NEXT-STEPS.md (phase-start template):

# [Project Name] — Next Steps

> Entry point for both parties. Use /project-continue to pick up any session.
> **Current phase:** Phase 1 — [Phase Name] | Active tasks: `phases/Phase-1-[name]/`

---

## Claude Response — YYYY-MM-DD

### Project created
- [x] Project folder structure created
- [x] ROADMAP.md initialised
- [x] STATUS.md initialised

### Next Steps for Talbot
- [ ] Review ROADMAP.md — adjust phases and tasks to reflect actual work breakdown
- [ ] When ready to begin: `/project-continue [name]`

## Talbot Response

---

Create LESSONS.md:

# [Project Name] — Lessons

> AI marks `[→ global CLAUDE.md]` or `[→ project CLAUDE.md]` candidates for Talbot to approve and promote.

---

Update Tasks/_active.md — add project link
Output confirmation with WSL + Windows paths to NEXT-STEPS.md and STATUS.md

Step 3: Verify the file was written correctly

Read back and confirm: ROADMAP.md creation step present, Simple/Complex tier prompt present, STATUS.md has Current Phase block, Feedback section absent, NEXT-STEPS.md uses phase-start template.

Step 4: Commit

cd /home/ta && git -C .claude add commands/project-start.md && git -C .claude commit -m "feat(smtm-v4): update project-start — ROADMAP, two-tier, phase-start template"

(If .claude is not a git repo, skip the commit — file is already saved.)

Task 2: Update `project-continue` skill

Files:

Modify: /home/ta/.claude/commands/project-continue.md
Step 1: Identify the changes needed

Current Step 2 reads STATUS.md for “current phase, blockers, and any Feedback section.” Changes needed:
- Read “Current Phase” block specifically (not just STATUS.md generally)
- Add sync check: verify STATUS.md phase names match ROADMAP.md before acting
- Remove reference to “Feedback section” (no longer in STATUS.md)

Step 2: Update the skill file

Replace Step 2 in the skill:

2. **Read the project's STATUS.md and ROADMAP.md**
   - Read STATUS.md — focus on the `## Current Phase` block at the top for orientation
   - Read ROADMAP.md — verify that phase/task names in STATUS.md match ROADMAP.md
   - **Sync check:** If phase names differ between STATUS.md and ROADMAP.md, stop and flag to Talbot:
     "STATUS.md and ROADMAP.md are out of sync — this indicates the ROADMAP sync hook may not be configured. Please confirm which is correct before proceeding."
   - Do NOT look for a Feedback section in STATUS.md — feedback comes via NEXT-STEPS.md Talbot Responses only

Also update Step 5 (was “Update STATUS.md”):

Remove “Clear the Feedback section if it was acted on”
Add “Do NOT edit phase/task descriptions in STATUS.md — those are managed by the ROADMAP sync hook”

Step 3: Verify

Read back the file. Confirm: “Current Phase” block mentioned, sync check present, Feedback removed.

Step 4: Commit

git -C ~/.claude add commands/project-continue.md && git -C ~/.claude commit -m "feat(smtm-v4): project-continue — Current Phase orientation, sync check, no Feedback"

Task 3: Update `project-task-complete` skill

Files:

Modify: /home/ta/.claude/commands/project-task-complete.md
Step 1: Identify changes needed

Current skill is close but needs:
- Explicit phase boundary enforcement (not just “end of session”)
- NEXT-STEPS.md reset to phase-start template (not just trim)
- Move completed phase folder to archive/
- LESSONS.md review step for CLAUDE.md/AGENTS.md promotion candidates
- Simple project closure sequence
- Remove “Update Tasks/_tmp.md” step (that file is human-only)

Step 2: Rewrite the skill

Replace with:

Wrap up a completed phase (or simple project) — archive NEXT-STEPS.md, update STATUS.md, move phase folder to archive/, review LESSONS.md.

Use at every **phase boundary** (Complex projects) or **project completion** (Simple projects). Do not use mid-phase.

## Steps

1. **Identify project and phase** — from context or ask

2. **Read STATUS.md** — confirm which phase just completed

3. **Tick completed phase in STATUS.md**
   - Mark phase `✅`
   - Set next phase as `🟡 (Active)`
   - Update `## Current Phase` block to point to the new phase
   - Update **Last Updated** date
   - Do NOT edit phase/task descriptions — those are synced by the ROADMAP hook

4. **Archive NEXT-STEPS.md cycles to a log file**
   - Create `logs/YYYY-MM-DD_Phase-N-[name].md`
   - Copy all completed `## Claude Response` / `## Talbot Response` cycles verbatim
   - Add `## Feedback` section at end for Talbot to fill in

   Log template:
   ```markdown
   # [Project Name] — Phase N: [Name]

   **Date:** YYYY-MM-DD
   **Project:** [name]
   **Phase:** N — [Name]

   ---

   [paste completed Claude/Talbot cycles here verbatim]

   ---

   ## Feedback
   <!-- Talbot fills in after review -->

Reset NEXT-STEPS.md to phase-start template

# [Project Name] — Next Steps

> Entry point for both parties. Use /project-continue to pick up any session.
> **Current phase:** Phase [N+1] — [Phase Name] | Active tasks: `phases/Phase-N+1-[name]/`

---

## Claude Response — YYYY-MM-DD

### Phase [N] complete — Phase [N+1] started
- [x] Phase [N] archived → logs/YYYY-MM-DD_Phase-N-[name].md
- [x] STATUS.md updated — Phase [N+1] now active

### Next Steps for Talbot
- [ ] [First task or decision for Phase N+1]

## Talbot Response

---

Move completed phase folder to archive/
- Move phases/Phase-N-[name]/ → archive/Phase-N-[name]/
- (Simple projects: no phase folders to move)
Review LESSONS.md for promotion candidates
- Read LESSONS.md
- Identify any entries that should propagate to global ~/.claude/CLAUDE.md or project CLAUDE.md
- Mark candidates with [→ global CLAUDE.md] or [→ project CLAUDE.md]
- Report candidates to Talbot for approval
Simple project closure only (if this is the final phase or a simple project completing):
- Mark STATUS.md as ✅ Complete
- Remove from Tasks/_active.md

Suggest context reset:

🧹 Context options:
A) /clear          — recommended before starting next phase
B) /session-save   — if returning within the hour
C) Continue        — if more work to do now

Output closing message with WSL + Windows paths to NEXT-STEPS.md, log, and STATUS.md
Suggest git commit

Step 3: Verify

Read back. Confirm: phase boundary language, NEXT-STEPS.md reset template, archive/ move step, LESSONS.md review step, simple project closure.

Step 4: Commit

git -C ~/.claude add commands/project-task-complete.md && git -C ~/.claude commit -m "feat(smtm-v4): project-task-complete — phase boundary, LESSONS review, NEXT-STEPS reset"

Task 4: Create `write-task-brief` skill

Files:

Create: /home/ta/.claude/commands/write-task-brief.md

Step 1: Create the file

Create a self-contained task brief for delegation to an external AI agent (Cursor, Claude Code, etc.) or for tracking a well-defined unit of work within a project.

## Usage

`/write-task-brief [project-name] [phase-number]`

## Steps

1. **Locate the target folder**
   - Complex project: `Projects/[name]/phases/Phase-[N]-[name]/`
   - Simple project: `Projects/[name]/`
   - If project/phase unclear, ask

2. **Gather task information** (ask one at a time if not provided):
   - Task number and short description (e.g., `3-reconciliation-engine`)
   - Assignee: talbot | claude | cursor | tbd
   - Is this task independent of other active tasks? (yes/no)
   - Prerequisites: which other tasks must complete first?

3. **Gather task content** (ask one at a time):
   - Context: what is this task for, and what does it enable downstream? (must be self-contained — no external docs required)
   - Reference files: which files must the agent read, and why?
   - Hard rules: any non-negotiable constraints?
   - Deliverables: exact outputs (files, tests, commands)
   - Completion signal: how do we know it's done?

4. **Write the task brief** to `Task-Brief-[N]-[descrip].md` in the target folder:

   ```markdown
   # Task Brief: [N]-[description]

   **Project:** [name]
   **Phase:** [N] — [phase name]
   **Status:** pending
   **Assignee:** [assignee]
   **Agent used:** [leave blank — filled in on completion]
   **Independent:** yes | no
   **Prerequisites:** [list or "none"]

   ---

   ## Context
   **Full task spec:** [Task-[N]-[descrip].md](Task-[N]-[descrip].md) — read this first.

   [Brief summary of what this delegation needs to accomplish and what it enables downstream.
   Do not duplicate content from the task file — link to it as SSoT.]

   ## Reference Files
   - `path/to/file` — why this file matters

   ## Hard Rules
   - [Rule 1]

   ## Deliverables
   [Exact outputs: files created/modified, tests that must pass, etc.]

   ## Completion Signal
   [How we know it's done — test output, build success, file exists, etc.]

   ---

   ## Agent Response
   [Agent appends summary here on completion — model used, what was done, issues found.
   This is an in-task summary only. Session logs are written to logs/ at phase completion.]

Update ROADMAP.md — add the task to the appropriate phase list if not already there
- After saving ROADMAP.md, the sync hook will update STATUS.md automatically
Output confirmation with WSL + Windows path to the task brief file

Step 2: Verify

Read back. Confirm: frontmatter fields present (including Agent used), filename is Task-Brief-N-[descrip].md, Context section opens with link to Task-N-[descrip].md as SSoT, Agent Response section present, ROADMAP.md update step, sync hook note.

Step 3: Commit

git -C ~/.claude add commands/write-task-brief.md && git -C ~/.claude commit -m "feat(smtm-v4): add write-task-brief skill for external agent delegation"

Task 5: Implement ROADMAP sync hook

Files:

Create: /mnt/d/FSS/Scripts/smtm-roadmap-sync.py
Modify: /home/ta/.claude/settings.json

The hook fires after any Edit/Write to a ROADMAP.md file. It reads the Phase/Task structure from ROADMAP.md and updates the corresponding STATUS.md to match — without touching checkboxes.

Step 1: Create the sync script

Create /mnt/d/FSS/Scripts/smtm-roadmap-sync.py:

#!/usr/bin/env python3
"""
SMTM ROADMAP → STATUS sync hook.
Reads ROADMAP.md phase/task names and updates STATUS.md to match.
Preserves all checkbox states. Only updates text descriptions.

Triggered by Claude Code PostToolUse hook on Edit/Write to ROADMAP.md.
Input: CLAUDE_TOOL_INPUT env var (JSON with file_path)
"""
import json
import os
import re
import sys
from pathlib import Path
from typing import Optional


def get_edited_file() -> Optional[str]:
    tool_input_str = os.environ.get("CLAUDE_TOOL_INPUT", "")
    if not tool_input_str:
        return None
    try:
        data = json.loads(tool_input_str)
        return data.get("file_path", "")
    except json.JSONDecodeError:
        return None


def find_status_md(roadmap_path: Path) -> Optional[Path]:
    """STATUS.md is always a sibling of ROADMAP.md."""
    status = roadmap_path.parent / "STATUS.md"
    return status if status.exists() else None


def parse_roadmap_phases(content: str) -> list[tuple[str, list[str]]]:
    """
    Parse ROADMAP.md and return list of (phase_name, [task_descriptions]).
    Handles both Complex (## Phase N — Name) and Simple (## Tasks) formats.
    """
    phases = []
    current_phase = None
    current_tasks = []

    for line in content.splitlines():
        # Phase heading: ## Phase 1 — Name  or  ## Tasks
        phase_match = re.match(r'^## (.+)$', line)
        if phase_match:
            if current_phase is not None:
                phases.append((current_phase, current_tasks))
            heading = phase_match.group(1).strip()
            # Skip Future/Backlog sections
            if heading.lower() in ('future / backlog', 'future', 'backlog'):
                current_phase = None
                current_tasks = []
            else:
                current_phase = heading
                current_tasks = []
        elif current_phase and re.match(r'^- Task-\d+:', line):
            # Task line: - Task-1: description
            task_match = re.match(r'^- (Task-\d+: .+)$', line)
            if task_match:
                current_tasks.append(task_match.group(1).strip())

    if current_phase is not None:
        phases.append((current_phase, current_tasks))

    return phases


def sync_status(status_content: str, roadmap_phases: list[tuple[str, list[str]]]) -> str:
    """
    Update STATUS.md phase/task descriptions to match ROADMAP.md.
    Preserves: checkboxes ([ ] and [x]), emoji (✅ 🟡 ⬜), (Active) markers.
    Does NOT modify: ## Current Phase block, Last Updated, or any checkbox states.
    """
    lines = status_content.splitlines(keepends=True)
    result = []
    phase_idx = 0
    task_idx = 0
    in_phase_section = False

    for line in lines:
        # Phase heading line: ## Phase N — Name ✅ or similar
        phase_heading_match = re.match(r'^(## )(Phase \d+ — |Tasks)(.*)$', line)
        if phase_heading_match and phase_idx < len(roadmap_phases):
            roadmap_phase_name, roadmap_tasks = roadmap_phases[phase_idx]
            # Extract trailing status markers (✅, 🟡, ⬜, (Active), etc.)
            trailing = re.search(r'[\s✅🟡⬜🔴]+(\(Active\))?[\s]*$', line)
            suffix = trailing.group(0) if trailing else '\n'
            # Rebuild heading with ROADMAP name + preserved status markers
            result.append(f'## {roadmap_phase_name}{suffix}')
            phase_idx += 1
            task_idx = 0
            in_phase_section = True
            continue

        # Task line in a phase section
        if in_phase_section:
            task_match = re.match(r'^(- \[[ x]\] )Task-\d+: .+$', line)
            if task_match and phase_idx > 0:
                tasks = roadmap_phases[phase_idx - 1][1]
                if task_idx < len(tasks):
                    checkbox = task_match.group(1)  # '- [ ] ' or '- [x] '
                    result.append(f'{checkbox}{tasks[task_idx]}\n')
                    task_idx += 1
                    continue
            elif re.match(r'^## ', line):
                in_phase_section = False

        result.append(line)

    return ''.join(result)


def main():
    edited_file = get_edited_file()
    if not edited_file or not edited_file.endswith('ROADMAP.md'):
        sys.exit(0)  # Not a ROADMAP.md edit — nothing to do

    roadmap_path = Path(edited_file)
    if not roadmap_path.exists():
        sys.exit(0)

    status_path = find_status_md(roadmap_path)
    if not status_path:
        print(f"[smtm-sync] No STATUS.md found alongside {roadmap_path}", file=sys.stderr)
        sys.exit(0)

    roadmap_content = roadmap_path.read_text(encoding='utf-8')
    status_content = status_path.read_text(encoding='utf-8')

    phases = parse_roadmap_phases(roadmap_content)
    if not phases:
        sys.exit(0)  # No phases parsed — leave STATUS.md alone

    updated = sync_status(status_content, phases)

    if updated != status_content:
        status_path.write_text(updated, encoding='utf-8')
        print(f"[smtm-sync] Synced STATUS.md from ROADMAP.md ({len(phases)} phases)")
    else:
        print(f"[smtm-sync] STATUS.md already in sync")


if __name__ == '__main__':
    main()

Step 2: Make the script executable

chmod +x /mnt/d/FSS/Scripts/smtm-roadmap-sync.py

Step 3: Add the PostToolUse hook to settings.json

Read /home/ta/.claude/settings.json, then add the PostToolUse hook:
```
"PostToolUse": [
  {
    "matcher": "(Edit|Write)",
    "hooks": [
      {
        "type": "command",
        "command": "python3 /mnt/d/FSS/Scripts/smtm-roadmap-sync.py"
      }
    ]
  }
]
```
Add "PostToolUse" as a sibling key to "Stop" and "Notification" inside the top-level "hooks" object in settings.json. Example structure:
```
{
  "hooks": {
    "Stop": [...],
    "Notification": [...],
    "PostToolUse": [
      {
        "matcher": "(Edit|Write)",
        "hooks": [{ "type": "command", "command": "python3 /mnt/d/FSS/Scripts/smtm-roadmap-sync.py" }]
      }
    ]
  }
}
```
Note: The matcher fires on all Edit/Write calls. The Python script itself filters to ROADMAP.md files via the CLAUDE_TOOL_INPUT env var — if not edited_file or not edited_file.endswith('ROADMAP.md'): sys.exit(0). This is the correct Claude Code hook pattern. This hook is also what enforces the design spec’s hard rule: “ROADMAP.md and STATUS.md are always updated atomically.”

Step 4: Test the hook manually

# Simulate what the hook would receive
export CLAUDE_TOOL_INPUT='{"file_path":"/mnt/d/FSS/KB/Business/_WorkingOn/Projects/test-proj/ROADMAP.md"}'
python3 /mnt/d/FSS/Scripts/smtm-roadmap-sync.py
# Expected: "[smtm-sync] No STATUS.md found alongside..." (since test-proj doesn't exist)
# This confirms the script runs without error

Step 5: Commit

git -C ~/.claude add settings.json && git -C ~/.claude commit -m "feat(smtm-v4): add ROADMAP PostToolUse sync hook"

Task 6: Update SMTM_System.md to v4

Files:

Modify: /mnt/d/FSS/KB/Business/03_Processes/Simple Markdown Task Management/SMTM_System.md

This is the largest single task — a documentation rewrite. The spec at SMTM-v4-design.md is the authoritative source.

Step 1: Read the current SMTM_System.md to understand what changes
Step 2: Update the version header

Change **Version:** 3.4 → **Version:** 4.0 — Updated 2026-03-24
Step 3: Update Project Lifecycle section

Replace the Project Lifecycle diagram and description with v4 content:
- Add ROADMAP.md to the lifecycle (created at project-start, updated when plan changes)
- Add phase boundary rule: project-task-complete required at every phase end
- Add NEXT-STEPS.md reset note: resets to phase-start template at phase boundary
Step 4: Update Small Project Structure

Add ROADMAP.md to the structure diagram. Add phases/ folder for Complex projects with a note that it’s Complex-only.
Step 5: Update STATUS.md template

Replace the STATUS.md template with the v4 version:
- Add ## Current Phase block at top
- Remove ## Key Files section
- Remove ## Feedback section (with note: “feedback goes in NEXT-STEPS.md as a Talbot Response”)
- Remove ## Notes / Blockers section (no longer in STATUS.md)
Step 6: Add ROADMAP.md template section

Add after STATUS.md template:
- Simple format (flat task list)
- Complex format (phase hierarchy)
- Note: living document, updated freely, sync hook maintains STATUS.md consistency
Step 7: Add NEXT-STEPS.md phase-start template section
Step 8: Add Task Brief template section

Include the full task brief format from spec, with note on Agent used field and Agent Response vs session logs.
Step 9: Update Skills table

Add /write-task-brief row. Update /project-start, /project-continue, /project-task-complete descriptions to reflect v4 behavior.
Step 10: Add ROADMAP sync hook note

New section: “ROADMAP ↔ STATUS Synchronization” explaining the hook, what it syncs (names only), what it preserves (checkboxes).

Step 11: Add v4 changelog at bottom

### v4.0 Changes
- Added ROADMAP.md as project TOC (living document, two formats: Simple/Complex)
- Two-tier project structure: Simple (<10 tasks) and Complex (multi-phase)
- STATUS.md is now state-only: added "Current Phase" block; removed Key Decisions, Feedback, Notes/Blockers
- NEXT-STEPS.md is phase-scoped: resets to template at every phase boundary
- project-task-complete is required at every phase boundary (not just end-of-session)
- LESSONS.md review added to all project closures: identify CLAUDE.md/AGENTS.md promotion candidates
- Task Brief format added (with Agent used field for model tracking)
- New /write-task-brief skill for external agent delegation
- ROADMAP sync hook: PostToolUse on ROADMAP.md updates STATUS.md descriptions automatically
- Feedback moved from STATUS.md to NEXT-STEPS.md (Talbot Response)
- LESSONS.md now captures process decisions and pivots (dev projects: DESIGN.md for technical decisions)
- Key Decisions removed from STATUS.md — technical decisions → DESIGN.md, process decisions → LESSONS.md
- _active.md retained unchanged (cross-project task tracker)

Step 12: Verify

Read back key sections. Confirm: ROADMAP.md present, STATUS.md template correct (no Feedback/Key Decisions), task brief template present, skills table updated.

Step 13: Commit

cd /mnt/d/FSS/KB/Business && git add "03_Processes/Simple Markdown Task Management/SMTM_System.md" && git commit -m "docs(smtm): rewrite to v4 — ROADMAP, two-tier, phase lifecycle, task briefs"

Task 7: Update MEMORY.md and CLAUDE.md files

Files:

Modify: /home/ta/.claude/projects/-home-ta-projects-monorepo/memory/MEMORY.md
Check/modify: relevant CLAUDE.md files

Step 1: Search for STATUS.md Feedback references in memory and CLAUDE.md files

grep -rn "Feedback" /home/ta/.claude/projects/*/memory/ 2>/dev/null
grep -rn "Feedback" /home/ta/projects/monorepo/ --include="CLAUDE.md" 2>/dev/null
grep -rn "Feedback" /mnt/d/FSS/KB/Business/ --include="CLAUDE.md" 2>/dev/null | head -20

Step 2: Update MEMORY.md

In the KB Task System section, make these changes:
- Update the section header: ## KB Task System (2026-03-21 v3.4) → ## KB Task System (2026-03-24 v4.0)
- “Session start: read Tasks/_tmp.md + relevant Projects/[name]/STATUS.md (check ## Feedback first)” → remove “check ## Feedback first”
- Add note: “STATUS.md has no Feedback section in v4 — feedback comes via NEXT-STEPS.md Talbot Responses”
- Add note about ROADMAP.md: “Projects now have ROADMAP.md as the living TOC; STATUS.md is state-only with a Current Phase block”
- Add note about phase-scoped NEXT-STEPS.md: “NEXT-STEPS.md is phase-scoped — it resets to a fresh template at every phase boundary via project-task-complete. It never accumulates across phases.”
Step 3: Update monorepo CLAUDE.md if needed

If CLAUDE.md files reference “check Feedback section in STATUS.md,” update to reference NEXT-STEPS.md instead.

Step 4: Commit memory changes

cd /home/ta && git -C .claude add projects/ && git -C .claude commit -m "chore(smtm-v4): remove STATUS.md Feedback references from memory"

Validation

After all tasks complete, validate end-to-end:

Invoke /project-start test-smtm-v4 in a fresh session — verify ROADMAP.md is created, STATUS.md has Current Phase block, NEXT-STEPS.md uses phase-start template, no Feedback section in STATUS.md
Edit a ROADMAP.md and verify the sync script fires (check for [smtm-sync] output) and STATUS.md phase names update
Invoke /write-task-brief — verify it prompts for the right fields and produces a correctly-formatted brief
Check SMTM_System.md v4 — confirm all new sections are present and accurate
Delete the test project once validated

Plan written 2026-03-24. Spec: SMTM-v4-design.md in same folder.

SMTM v4 Implementation Plan

File Structure

Task 1: Update project-start skill

Task 2: Update project-continue skill

Task 3: Update project-task-complete skill

Task 4: Create write-task-brief skill

Task 5: Implement ROADMAP sync hook

Task 6: Update SMTM_System.md to v4

Task 7: Update MEMORY.md and CLAUDE.md files

Validation

Task 1: Update `project-start` skill

Task 2: Update `project-continue` skill

Task 3: Update `project-task-complete` skill

Task 4: Create `write-task-brief` skill