---
phase: 01.8-add-workflows-templated-artifacts
plan: 01
type: execute
wave: 1
depends_on: []
files_modified:
  - src/gsd_lite/template/ARCHITECTURE.md
  - src/gsd_lite/template/PROJECT.md
autonomous: true

must_haves:
  truths:
    - "ARCHITECTURE.md template provides structure for any project type (web app, CLI, dbt, Docker, monorepo)"
    - "PROJECT.md template captures vision, core value, and success criteria without enterprise overhead"
    - "Both templates are grep-friendly with consistent header structure"
  artifacts:
    - path: "src/gsd_lite/template/ARCHITECTURE.md"
      provides: "Codebase mapping output template"
      contains: "## Project Structure"
    - path: "src/gsd_lite/template/PROJECT.md"
      provides: "Project initialization output template"
      contains: "## Core Value"
  key_links:
    - from: "ARCHITECTURE.md"
      to: "WORK.md"
      via: "Discovery entries reference architecture findings"
      pattern: "\\[DISCOVERY\\]"
    - from: "PROJECT.md"
      to: "WORK.md"
      via: "Success criteria connect to task completion"
      pattern: "Success Criteria"
---

<objective>
Create lightweight ARCHITECTURE.md and PROJECT.md templates optimized for GSD-lite's single-agent, grep-friendly approach.

Purpose: These templates are the OUTPUT artifacts that map-codebase and new-project workflows produce. They must work for any project type (not just Docker containers) and integrate with WORK.md logging.

Output: Two template files in `src/gsd_lite/template/` ready for workflow use.
</objective>

<context>
@.planning/phases/01.8-add-workflows-templated-artifact-for-codebase-mapper-and-new-project-inspired-from-gsd-upstream-workflows/01.8-CONTEXT.md

Reference patterns (OG GSD - adapt, don't copy):
@.claude/get-shit-done/templates/project.md
@.claude/get-shit-done/templates/codebase/architecture.md

Quality examples from eval:
@.planning/phases/01.8-add-workflows-templated-artifact-for-codebase-mapper-and-new-project-inspired-from-gsd-upstream-workflows/evals/PROJECT.md
@.planning/phases/01.8-add-workflows-templated-artifact-for-codebase-mapper-and-new-project-inspired-from-gsd-upstream-workflows/evals/ARCHITECTURE.md
</context>

<tasks>

<task type="auto">
  <name>Task 1: Create ARCHITECTURE.md template</name>
  <files>src/gsd_lite/template/ARCHITECTURE.md</files>
  <action>
Create `src/gsd_lite/template/ARCHITECTURE.md` with this structure (from CONTEXT.md decisions):

**Required sections:**
1. `## Project Structure Overview` - Table mapping directories to semantic meaning (2 levels deep: root + one level down)
2. `## Tech Stack` - Condensed: runtime, language, 2-5 critical dependencies only
3. `## Data Flow` - Mermaid diagram OR 3-5 step text description (agent chooses based on project)
4. `## Entry Points` - "Start reading here" pointers with file paths

**Design principles:**
- Single merged file (not 7 separate files like OG GSD)
- Generalized for any project type (web apps, CLI tools, dbt projects, Docker infra, monorepos)
- Include placeholder guidance text showing what to fill in
- Grep-friendly headers (consistent `## ` level-2 structure)
- Drop: concerns.md, conventions.md, integrations.md, testing.md, structure.md (concerns log in WORK.md as `[DISCOVERY]` entries)

**Reference the eval example** at `.planning/phases/01.8-.../evals/ARCHITECTURE.md` for quality/density (~40 lines is good).

**Format:**
```markdown
# Architecture

*Mapped: [date]*

## Project Structure Overview

| Directory | Purpose |
|-----------|---------|
| [path/] | [semantic meaning] |

## Tech Stack

- **Runtime:** [e.g., Node.js 20, Python 3.11, Docker]
- **Language:** [e.g., TypeScript, Python, Go]
- **Key Dependencies:** [2-5 critical ones only]

## Data Flow

[Mermaid diagram OR 3-5 step text description]

## Entry Points

Start reading here:
- `[path/to/main.ts]` - [what it does]
- `[path/to/config]` - [what it does]

---
*Update when architecture changes significantly*
```
  </action>
  <verify>File exists at `src/gsd_lite/template/ARCHITECTURE.md` with all 4 required sections</verify>
  <done>ARCHITECTURE.md template is generalized, grep-friendly, and ~30-50 lines</done>
</task>

<task type="auto">
  <name>Task 2: Create PROJECT.md template</name>
  <files>src/gsd_lite/template/PROJECT.md</files>
  <action>
Create `src/gsd_lite/template/PROJECT.md` with this structure (from CONTEXT.md decisions):

**Required sections:**
1. `## What This Is` - 2-3 sentence description
2. `## Core Value` - The ONE thing that must work (single sentence)
3. `## Success Criteria` - Simple checkbox list of "project succeeds when..." items
4. `## Context` - Background info informing implementation
5. `## Constraints` - Hard limits with rationale

**Design principles:**
- Lightweight (NOT the heavy OG GSD structure with Validated/Active/Out of Scope lifecycle)
- Success Criteria provides "5000ft view" connecting WORK.md logs to overall intent
- Drop: Key Decisions table (decisions logged in WORK.md instead)
- Drop: Validated/Active/Out of Scope breakdown (too heavy for GSD-lite)
- Include placeholder guidance showing what to fill in
- Grep-friendly headers (consistent `## ` level-2 structure)

**Reference the eval example** at `.planning/phases/01.8-.../evals/PROJECT.md` for quality/density.

**Format:**
```markdown
# [Project Name]

*Initialized: [date]*

## What This Is

[2-3 sentence description. What does this do and who is it for?]

## Core Value

[The ONE thing that matters most. If everything else fails, this must work.]

## Success Criteria

Project succeeds when:
- [ ] [Observable outcome 1]
- [ ] [Observable outcome 2]
- [ ] [Observable outcome 3]

## Context

[Background that informs implementation:
- Technical environment
- Prior work or constraints
- User needs or feedback]

## Constraints

- **[Type]:** [What] - [Why]
- **[Type]:** [What] - [Why]

---
*Update when project scope changes*
```
  </action>
  <verify>File exists at `src/gsd_lite/template/PROJECT.md` with all 5 required sections</verify>
  <done>PROJECT.md template is lightweight, grep-friendly, and ~30-40 lines</done>
</task>

</tasks>

<verification>
After both tasks complete:
1. `ls src/gsd_lite/template/*.md` shows ARCHITECTURE.md and PROJECT.md exist
2. `grep "^## " src/gsd_lite/template/ARCHITECTURE.md` returns 4 level-2 headers
3. `grep "^## " src/gsd_lite/template/PROJECT.md` returns 5 level-2 headers
4. Neither template contains OG GSD patterns like "Validated/Active/Out of Scope" or 7-file structure
</verification>

<success_criteria>
- ARCHITECTURE.md template exists with Project Structure, Tech Stack, Data Flow, Entry Points sections
- PROJECT.md template exists with What This Is, Core Value, Success Criteria, Context, Constraints sections
- Both templates are generalized (not Docker-specific)
- Both templates are ~30-50 lines (lightweight)
- Both templates use consistent `## ` header structure for grep
</success_criteria>

<output>
After completion, create `.planning/phases/01.8-add-workflows-templated-artifact-for-codebase-mapper-and-new-project-inspired-from-gsd-upstream-workflows/01.8-01-SUMMARY.md`
</output>
