Artifact catalog

# CLAUDE.md

## Commands
- check: `npm run check`
- test: `npm test`

## Rules
- Keep changes inside the task scope.
- Report changed files and verification results.

## Do not
- Read or edit secrets without explicit approval.

# CLAUDE.local.md

## Local context
- Database: localhost:<port>
- Fixture directory: <local-path>

## Preferences
- Explain the plan before multi-file changes.

# Rule: <area-name>

Applies to: `src/<area>/**`

- Preserve the public contract.
- Run the focused checks after changes.
- Do not edit unrelated files.

{
  "permissions": {
    "allow": ["Bash(npm run check)"],
    "deny": ["Read(.env)"]
  },
  "env": {
    "PROJECT_MODE": "<mode>"
  }
}

{
  "permissions": {
    "allow": ["Bash(npm run check)"],
    "deny": ["Read(.env)"]
  }
}

# AI coding policy

## Allowed
- <low-risk use>

## Review required
- <change or capability>

## Human approval required
- <production or destructive action>

## Data boundaries
- Never include secrets, PII, or customer data without approved controls.

## Enforcement
- <settings, hooks, gates, and owner>

# CODEOWNERS

# Default owner
* @<team-or-role>

# Sensitive area
/src/<area>/** @<approved-owner>

# Configuration
/.claude/** @<workflow-owner>

# Task spec — <short task name>

## Goal
- <problem and desired outcome>

## Scope
- <files or behavior included>

## Non-goals
- <explicitly excluded work>

## Acceptance criteria
- <verifiable condition>

## Verification
- <command or manual check>

# Project specification

## Problem
<problem statement>

## Audience
<primary users>

## Scope
- <included capability>

## Non-goals
- <excluded capability>

## Acceptance criteria
- <measurable result>

# Capstone brief

## Shared expectations
- Deliver one complete core flow.
- Keep the scope reviewable.

## Guardrails
- No secrets in the repository.
- Record checks and remaining risks.

# Roadmap

## Milestones
1. Discovery — map the current behavior.
2. Implementation — deliver the core flow.
3. Verification — run checks and prepare evidence.

## Evaluation
- <criterion for milestone completion>

# CONTRACT.md

## Parties
- Producer: <role/component>
- Consumer: <role/component>

## Input
- <required input>

## Output
- <expected output>

## Invariants
- <must remain true>

## Failure/stop conditions
- <condition>

# PLAN.md

## Goal
<desired outcome>

## Scope
- <included paths or behavior>

## Steps
1. <inspect>
2. <change>
3. <verify>

## Risks
- <risk or none>

## Stop condition
- <when to pause and ask>

# REFACTORING_PLAN.md

## Goal
<one structural improvement>

## Allowed scope
- <paths, symbols, or seam>

## Preserve
- <public behavior and invariants>

## Non-goals
- <feature, dependency, or unrelated cleanup>

## Steps
1. <inspect>
2. <change>
3. <check and review>

## Stop and rollback
- <condition and checkpoint>

# MODERNIZATION_ROADMAP.md

## Outcome and constraints
<why modernization matters and what is out of scope>

## Milestones
| Slice | Owner | Dependency | Evidence gate | Exit criteria | Rollback/hold |
| --- | --- | --- | --- | --- | --- |
| <slice> | <role> | <dependency> | <check> | <observable result> | <action> |

## Retirement plan
- <legacy removal condition>

## Open risks
- <risk and next decision>

# MIGRATION_PLAN.md

## Outcome and boundaries
- Source: <current state>
- Target: <target state>
- Scope: <bounded slice>
- Non-goals: <excluded changes>

## Phases
| Phase | Scope | Owner | Evidence gate | Exit criteria | Rollback/HOLD |
| --- | --- | --- | --- | --- | --- |
| Discovery | <facts and unknowns> | <role> | <anchor> | <result> | <hold action> |
| Analysis | <compatibility work> | <role> | <anchor> | <result> | <narrow action> |
| Pilot | <small slice> | <role> | <behavior check> | <result> | <rollback> |

## GO / HOLD decision
- Decision: <GO | HOLD | NARROW | ROLLBACK>
- Evidence: <facts>
- Open risks: <items>

# MIGRATION_TYPES.md

## Scope
- Source state: <current state>
- Target state: <target state>
- Boundary: <bounded initiative or pilot>

## Classification
| Work item | Type | Source -> target | Coupled with | Evidence gate | Owner | Status |
| --- | --- | --- | --- | --- | --- | --- |
| <item> | <code/dependency\|schema/data\|configuration\|infrastructure/platform\|operational> | <states> | <dependencies> | <check> | <role> | <Unknown/HOLD/ready> |

## Ordering and stop conditions
- <dependency or blocking unknown>
- <condition that stops the pilot>

# DATA_CONFIG_MIGRATION.md

## Scope and representations
- Data source -> target: <format/schema/state>
- Configuration source -> target: <keys/defaults/environments>
- Compatibility window: <coexistence period or Unknown>

## Plan
| Surface | Inventory | Sequence | Validation | Recovery | Owner | Status |
| --- | --- | --- | --- | --- | --- | --- |
| <schema/records/config/secrets references> | <items> | <ordered action> | <check> | <backout/forward-fix> | <role> | <Unknown/HOLD/ready> |

## Safety boundaries
- Never store secret values in this document.
- <irreversible action and explicit approval/stop condition>

# VALUE_PROPOSITION.md

## User and problem
- User: <primary user>
- Problem: <recurring loss or friction>

## Promise
- Alternative: <how the user solves it today>
- Outcome: <observable improvement>
- Differentiation: <why this approach may help>

## Proof boundary
- Signal: <metric or observation>
- Assumptions: <assumptions to validate>
- Status: documented example; user validation is Unknown.

# USER_JTBD.md

## Situation
- User: <specific role>
- Trigger/context: <when this job appears>

## Job
- When <situation>, I want to <job>, so I can <desired outcome>.

## Constraints
- Pains: <friction>
- Gains: <desired progress>
- Constraints: <time, access, policy or quality limits>

## Validation boundary
- Assumptions: <what still needs research>
- Status: documented example; observed user behavior is Unknown.

# SUCCESS_METRIC.md

## Metric
- Name: <metric name and unit>
- Definition: <what counts and what does not>
- Baseline: <known baseline or Unknown>
- Target: <bounded target>
- Window: <observation period>

## Method and guardrails
- Collection: <how the signal would be observed>
- Leading signal: <flow completion or quality signal>
- Guardrail: <quality, safety or rework constraint>
- Limits: <what this metric cannot prove>
- Status: documented example; no measured outcome is claimed.

# RELEASE_SLICE.md

## Core flow
- User: <primary user>
- Trigger: <starting situation>
- Flow: <bounded steps>
- Outcome: <observable result>

## Boundaries
- In scope: <included capabilities>
- Non-goals: <explicit exclusions>
- Deferred: <safe follow-up work>

## Gates
- Dependencies: <known dependencies>
- Risks: <risk and stop condition>
- Release criteria: <reviewable conditions>
- Status: documented example; no release or deployment is claimed.

# CAPSTONE_RUBRIC.md

Dimension: <problem / flow / scope / verification / evidence / communication>
Expected signal: <observable criterion>
Evidence required: <file, command or demo anchor>
Status scale: <not shown / partial / shown / needs verification>
Weight: <agreed value or Unknown>
Reviewer note: <feedback or Unknown>
Decision boundary: <GO / HOLD / remediation>
Status: documented example; rubric application and score: Unknown.

# TARGET_ROLE_STRATEGY.md\n\nRole families: <target roles and responsibility>\nConstraints: <location, format, level, time>\nEvidence: <verified proof-of-work or Unknown>\nSearch hypotheses: <source and priority signal>\nNext action: <one bounded manual check>\nBoundary: applications, recruiter responses, interviews and hiring outcome are Unknown.\nStatus: documented example.\n

# JOB_FIT_GAP_MAP.md\n\nRole/source: <vacancy and URL or Unknown>\n\n| Requirement | Status | Evidence | Confidence | Next check |\n| --- | --- | --- | --- | --- |\n| <must-have> | Fit / Partial / Gap / Unknown | <source or Unknown> | <high/medium/low> | <bounded action> |\n\nBoundary: this map is not an external assessment and does not prove hiring fit.\nStatus: documented example.\n

# APPLICATION_TAILORING.md\n\nTarget role: <role or Unknown>\nSource claim: <verified experience or Unknown>\nRole relevance: <why it matters>\nTailored wording: <bounded claim>\nNot claimed: <missing metric, employer, outcome or review>\nHuman check: <required before external submission>\nStatus: documented example; application and hiring outcome: Unknown.\n

# Evidence

## Result
<what was checked and what happened>

## Decisions
- <decision and rationale>

## Verification
- `<command>` — <result>

## Open risks
- <unresolved item or none>

# Handoff note

## Goal and scope
<what this work covers>

## Changed files
- `<path>` — <change>

## Decisions
- <decision>

## Checks
- `<command>` — <result>

## Next step
<one concrete next action>

## Summary
<what changed>

## Scope
- Included: <area>
- Not included: <non-goal>

## Checks
- `<command>` — <result>

## Risks
- <risk or none>

<type>(<scope>): <short imperative summary>

Explain why the change is needed and mention verification when useful.

# Changelog

## [Unreleased]
### Added
- <user-visible capability>

### Fixed
- <user-visible bug fix>

### Migration notes
- <required action or none>

# HANDOFF_REVIEW.md

## Reviewed handoff
- Source: <handoff path>
- Scope: <reviewed scope>

## Confirmed
- <evidence-backed item>

## Findings
- <finding or none>

## Next decision
- <action and owner>

# Postmortem: <incident or failure>

## Impact
<observable impact and duration>

## Timeline
- <time> — <event>

## Root cause and contributing factors
- <verified cause>

## What worked / failed
- <control> — <result>

## Actions
- [ ] <owner> — <preventive or corrective action>

## Verification
- <how the fix will be checked>

# REVIEW_NOTES.md

## Scope reviewed
- <paths or behavior>

## Findings
- <severity> — <file:line> — <finding>

## Checks
- `<command>` — <result>

## Open questions
- <question or none>

## Verdict
<APPROVE | REWORK | HOLD>

# Project delivery runbook

**Last updated:** <YYYY-MM-DD>

## Task log

### <task name> — `<implemented|reviewed|partially verified|not performed>`
- Goal and scope: <what was requested>
- Changed or reviewed files: `<paths>`
- Result: <confirmed outcome>
- Verification: `<command or manual check>` — <actual result>
- Limitations: <known gap or none>

## Open limitations
- <unverified item or none>

# MODERNIZATION_ANTI_PATTERNS.md

## Anti-pattern: <name>
- Signal: <observable warning>
- Impact: <possible consequence>
- Safer alternative: <bounded practice>
- Stop condition: <when to pause>
- Evidence: <anchor>

# MIGRATION_VALIDATION_REPORT.md

## Scope and baseline
- Source revision: <revision>
- Target revision: <revision>
- Pilot slice: <bounded surface>

## Checks
| Dimension | Expected | Observed | Evidence anchor | Status |
| --- | --- | --- | --- | --- |
| behavior inputs/outputs/errors/side effects | <contract> | <observation> | <test/log/fixture> | <pass/fail/Unknown> |
| data integrity and counts | <invariant> | <observation> | <command/result> | <pass/fail/Unknown> |
| configuration and startup | <expected mapping> | <observation> | <check> | <pass/fail/Unknown> |

## Decision
- Discrepancies: <none or described>
- Decision: <GO | HOLD | NARROW | ROLLBACK>
- Confidence and limits: <what remains Unknown>
- Status: documented example; no migration validation was executed.

# POST_MIGRATION_NOTES.md

## Scope and decision
- Migration slice/checkpoint: <bounded surface>
- Switch decision: <GO | HOLD | NARROW | ROLLBACK>
- Observation window: <window or Unknown>

## Observations
| Signal | Expected | Observed | Evidence | Status |
| --- | --- | --- | --- | --- |
| representative behavior | <contract> | <observation> | <anchor> | <pass/fail/Unknown> |
| data/configuration state | <invariant> | <observation> | <anchor> | <pass/fail/Unknown> |
| operational signal | <threshold> | <observation> | <anchor> | <pass/fail/Unknown> |

## Follow-up and handoff
- Residual risk: <risk or Unknown>
- Next action: <bounded action>
- Owner: <role>
- Lessons learned: <observation>
- Never store secret values here.
- Status: documented example; no post-migration outcome is claimed.

# Codebase inventory

## Stack
- Language: <language>
- Framework: <framework>

## Entry points
- <path> — <purpose>

## Commands
- Run: `<command>`
- Check: `<command>`

## Risk areas
- <area and reason>

# API map

| Route | Handler | Boundary | Checks |
| --- | --- | --- | --- |
| `GET /<resource>` | `<handler>` | `<DB or service>` | `<test>` |

## Environment
- `<ENV_NAME>` — <purpose>

# CLAWD Wisdom

## <lesson>
- Context: <where this applies>
- Evidence: <file, command, or source>
- Insight: <verified reusable conclusion>
- Limitation: <where it does not apply>
- Reviewed: <date or version>

# Research digest

## Question
<question>

## Sources
- <source> — <what it supports>

## Findings
- <confirmed finding>

## Unknowns
- <unverified item>

## Recommendation
<next safe step>

# DEBT_SIGNALS.md

## Scope and date
- Area: <module or flow>
- Reviewed: <date or revision>

## Signals
| Area | Evidence | Risk | Next step |
| --- | --- | --- | --- |
| <area> | <path, command, report, or commit> | <possible impact> | <one concrete check> |

## Limitations
- A signal is an indicator, not proof of a defect.

# RISK_MAP.md

## Risk entries
| Area | Business criticality | Change risk | Categories | Evidence | Missing checks | Recommended action |
| --- | --- | --- | --- | --- | --- | --- |
| <area> | <low|medium|high> | <low|medium|high> | <categories> | <anchors> | <checks> | <decision> |

## Unknowns
- <unknown and owner or verification step>

# ARCHITECTURE_CURRENT.md

## Document purpose
<actual current behavior, not desired architecture>

## Subsystems
## Critical flows
## Confirmed facts
## Assumptions
## Manual checks needed
## Differences from historical documentation

# BEHAVIOR_INVENTORY.md

## Flow: <business flow>
- Current behavior: <confirmed facts and confidence>
- Inputs: <reproducible inputs>
- Outputs: <observable outputs>
- Existing tests: <paths and level>
- Missing checks: <gaps>
- Characterization candidate: <yes|no> — <reason>
- Evidence: <anchors>

# CRITICAL_FLOWS.md

## Flow: <name>
- Trigger: <event or entry point>
- Inputs: <state and data>
- Steps: <ordered components>
- Side effects: <writes, integrations, notifications>
- Output: <observable result>
- Failure path: <error, retry, rollback, or escalation>
- Evidence: <anchors>

# MODULE_INVENTORY.md

## Module: <name>
- Path: <path>
- Responsibility: <observed responsibility>
- Entry points: <symbols or routes>
- Dependencies: <internal and external>
- Tests: <paths and coverage signal>
- Owner: <confirmed or inferred>
- Risks and unknowns: <items>
- Evidence: <anchors>

# MODERNIZATION_BASELINE.md

## Scope and revision
- Module/flow: <area>
- Revision: <commit or date>

## Observable behavior
- Inputs: <inputs>
- Outputs: <outputs>
- Side effects: <effects>
- Failure paths: <errors and recovery>

## Invariants
- <contract that must remain true>

## Checks and observability
- `<command or scenario>` — <actual result>

## Rollback point and unknowns
- Checkpoint: <reference>
- Unknowns: <items>

# SEAM_MAP.md

## Flow and boundary
- Flow: <business or runtime flow>
- Entry point: <caller>

## Current path
- Caller: <component>
- Legacy callee: <component>
- Side effects: <effects>

## Candidate seam
- Interface/adapter/event/routing: <boundary>
- Dependency direction: <producer -> consumer>
- Test seam: <how to observe it>

## Migration risk and next slice
- Risk: <risk>
- Next check: <one verification>

# MIGRATION_DISCOVERY.md

## Source and target
- Source state: <runtime, framework, platform, or version>
- Target state: <runtime, framework, platform, or version>
- Migration slice: <bounded area>

## Evidence
- <repository, build, deployment, integration or official-doc anchor>

## Known, assumed, unknown
- Known: <confirmed fact>
- Assumption: <assumption and owner>
- Unknown: <question and next check>

## Starting checkpoint
- Revision/environment: <reference>
- Baseline check: <command or scenario>

## Stop conditions
- <condition that blocks analysis or pilot>

# CHANGELOG_RESEARCH.md

## Version window
- Source: <version>
- Target: <version>

## Findings
| Version | Official section | Change type | Affected area | Impact | Confidence | Next check |
| --- | --- | --- | --- | --- | --- | --- |
| <version> | <URL or section> | <breaking/deprecated/behavior/config> | <path or component> | <possible impact> | <confirmed/needs verification/Unknown> | <check> |

## Limits
- <release or repository fact not verified>

# DEPENDENCY_GRAPH.md

## Nodes
| Node | Source | Target | Type | Evidence |
| --- | --- | --- | --- | --- |
| <component> | <source state> | <target state> | <runtime/framework/plugin/integration> | <anchor> |

## Directed edges
- <producer> -> <consumer>: <contract or version constraint>

## Affected flows
- <flow>: <entry point, path and side effects>

## Hubs and unknowns
- High-impact hub: <node and reason>
- Unknown: <edge or constraint and next check>

# COMPATIBILITY_MATRIX.md

## Scope
- Source: <version or platform>
- Target: <version or platform>

## Decisions
| Component/edge | API | Config | ABI | Runtime | Data format | Protocol | Operations | Status | Evidence | Owner |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| <item> | <status> | <status> | <status> | <status> | <status> | <status> | <status> | <compatible/blocking/Unknown> | <anchor> | <role> |

## Blocking and unknown items
- <item> — <next check or hold decision>

---
name: <skill-name>
description: <what this workflow does>
argument-hint: "[input-path] [focus]"
---

# <Skill title>

## When to use
Use when <trigger>.

## Steps
1. Inspect the input.
2. Perform the focused workflow.
3. Return evidence and remaining risks.

## Constraints
- Do not modify files outside the declared scope.

---
name: <reviewer>
description: Reviews <area> and returns evidence-backed findings.
tools: Read, Grep
---

# Role
Inspect only the assigned scope.

# Output
- Finding
- File and line
- Evidence
- Confidence

# Prohibitions
Do not edit files or broaden the scope.

event: <lifecycle-event>
matcher: <path-or-condition>
handler: <command-or-script>
mode: non-blocking
kill_switch: <how-to-disable>

name: <plugin-name>
version: 0.1.0
manifest:
  skills:
    - <skill-name>
  agents:
    - <agent-name>
permissions:
  - <required-access>

# Commands

## <workflow>
- Purpose: <what it verifies or changes>
- Run from: <directory>
- Command: `<command>`
- Expected result: <observable output>
- Stop if: <failure or unsafe condition>

# CLAWD YOLO

## Allowed scope
- Paths: <narrow paths>
- Actions: <allowed actions>

## Guardrails
- No secrets or destructive operations.
- Stop on: <failure signal>
- Human checkpoint: <before merge or release>

# Workflow: <name>

## Trigger
<when to use>

## Inputs
- <input>

## Stages
1. <stage and owner>
2. <stage and owner>

## Evidence
- <output artifact>

## Failure path
<how to stop, retry, rollback, or escalate>

server: <server-name>
transport: <stdio|http>
command: <command>
scope: project
auth: REDACTED
healthcheck: <status command>

git switch -c <branch-name>
git status
git diff -- <path>
# Review the diff, run checks, then create a checkpoint.

# CLAWD Runner

run: <human-readable name>
input: <path or task id>
command: `<command>`
environment: <local|ci|staging>
status: <planned|running|passed|failed|stopped>
output: <artifact path or summary>

{
  "defaultLocale": "<locale>",
  "supportedLocales": ["<locale>"],
  "fallbackLocale": "<locale>",
  "namespaces": ["<namespace>"]
}

# Locale bundle

## Contract
- Locale: <locale>
- Keys added/changed: <keys>

## Layers
- API: <paths>
- UI: <paths>
- Tests: <paths>

## Verification
- `<command>` — <result>

run_id: <opaque-id>
workflow: <name>
status: <planned|running|passed|failed|stopped>
stages:
  - name: <stage>
    status: <status>
    evidence: <path-or-summary>
updated_at: <timestamp>

{
  "status": "<failure|healthy|unknown>",
  "class": "<test|build|environment|flaky|contract>",
  "evidence": ["<redacted-log-line>"],
  "confidence": "<high|medium|low>",
  "nextAction": "<safe next step>"
}

# CHARACTERIZATION_TESTS.md

## Scope and baseline
- Module/flow: <area>
- Revision: <commit or date>
- Behavior under test: <observable contract>

## Cases
| Case | Inputs | Expected observable output | Side effects | Evidence |
| --- | --- | --- | --- | --- |
| <case> | <reproducible input> | <status, value, event, or error> | <effect or none> | <test/log/source> |

## Invariants
- <behavior that must remain unchanged>

## Run and interpretation
- Command: `<focused test command>`
- Baseline result: <actual result>
- Stop if: <unexpected behavior or missing evidence>

## Limits
- <unknown behavior or scenario not covered>

# STRANGLER_SLICE.md

## Fragment and boundary
<bounded behavior being replaced>

## Paths
- Legacy: <old path>
- New: <new path>
- Router: <explicit selection rule>

## Compatibility and side effects
- Contract: <preserved behavior>
- Side effects: <single-write/idempotency rule>
- Observability: <signals>

## Rollout and rollback
- Rollout: <small expansion>
- Rollback: <switch and state recovery>

## Retirement criteria
- <evidence required before removing legacy>

# ROLLBACK.md

## Boundary
- Scope: <bounded pilot>
- Checkpoint: <source revision/config/state checkpoint>
- Trigger: <observable threshold or blocking discrepancy>
- Owner: <role>

## Ordered recovery
1. <route traffic or stop the affected slice>
2. <restore code or artifact>
3. <restore compatible configuration>
4. <backout data/schema or choose forward-fix>
5. <verify representative behavior and invariants>

## Decision
- State recovery: <verified/Unknown>
- Decision: <GO | HOLD | ROLLBACK>
- Never store secret values here.
- Status: documented example; no recovery was executed.

# Project name

## Setup
```bash
npm install
npm run dev
```

## Scope
<what this project contains>

## Verification
- `npm run check`

# CONTROLLED_VIBE_CODING.md

Goal: <one bounded change>
Allowed paths: <explicit files or directories>
Expected diff: <one behavior; no unrelated cleanup>
Check: <targeted command or review step>
Stop when: <scope drift, unclear contract or missing oracle>
Human gate: <continue / revise / HOLD>
Status: documented example; execution result: Unknown.

# IMPLEMENTATION_SPRINT_PLAN.md

Outcome: <reviewable increment>
Slices: <ordered implementation slices>
Owner: <role>
Dependencies: <known prerequisites>
Checkpoint: <diff and verification review>
Exit: <DONE / CONTINUE WITH APPROVAL / HOLD>
Deferred: <excluded work>
Status: documented example; sprint execution: Unknown.

# DEMO_QUALITY_GATE.md

Core flow: <bounded scenario>
Blocking: <startup, output and acceptance checks>
Advisory: <non-critical signals>
Evidence: <commands or anchors>
Decision: <GO / HOLD / REDO>
Claims excluded: <production, adoption or scale claims>
Status: documented example; gate result: Unknown.

# DEMO_READINESS.md

Scenario: <bounded flow>
Start: <command or manual entry point>
Inputs: <safe fixtures>
Expected signal: <observable output>
Fallback: <static or manual alternative>
Blocking unknowns: <environment or permission gaps>
Deployment boundary: no publish/deploy claim
Status: documented example; readiness result: Unknown.

# CAPSTONE_DEFENSE_HANDOFF.md

Problem: <bounded problem>
Demo path: <observable steps>
Evidence: <links or anchors>
Known limits: <unsupported cases and Unknowns>
Claims excluded: <production, adoption, scale>
Decision requested: <GO / HOLD / feedback>
Next owner: <role>; next step: <bounded action>
Status: documented example; defense outcome: Unknown.

# DEMO.md

## Scenario
- Audience: <reviewer or evaluation context>
- Core flow: <bounded scenario>
- Entry point: <safe command or manual start>

## Run-through
1. <step and expected signal>
2. <step and expected signal>
3. <step and expected signal>

## Boundaries
- Known limits: <unsupported cases and Unknowns>
- Claims excluded: <production, adoption, scale>
- Status: documented example; demo outcome: Unknown.

# EVIDENCE_LOG.md

## Entry
- Time/context: <bounded checkpoint>
- Claim: <what is being checked>
- Source: <file, command or observation>
- Result: <observed result or Unknown>
- Decision: <continue / revise / HOLD>
- Owner: <role>

## Boundary
- This log does not prove deployment, user validation or production readiness.
- Status: documented example.

# HANDOFF_PACKAGE.md

## Summary
- Problem: <bounded problem>
- User: <primary user or reviewer>
- Scope: <implemented/documented slice>

## Package
- Demo: <DEMO.md anchor>
- Quality gate: <DEMO_QUALITY_GATE.md anchor>
- Readiness: <DEMO_READINESS.md anchor>
- Evidence log: <EVIDENCE_LOG.md anchor>
- Defense handoff: <CAPSTONE_DEFENSE_HANDOFF.md anchor>

## Decision
- Requested: <GO / HOLD / feedback>
- Next owner: <role>
- Status: documented example; handoff outcome: Unknown.

# SUBMISSION_PACKAGE.md

Problem: <bounded problem>
Core flow: <one observable scenario>
Start: <safe command or manual entry point>
Inputs: <fixtures without secrets>
Expected signal: <observable output>
Evidence: <diff, checks and notes>
Repro audit: <REPRO_AUDIT.md anchor>
Known limits: <unsupported cases and Unknowns>
Status: documented example; submission and reproducibility result: Unknown.

# REPRO_AUDIT.md

Starting state: <clean checkout or documented baseline>
Prerequisites: <versions, commands and safe fixtures>
Steps: <ordered reproduction actions>
Expected: <observable signal>
Observed: <result or Unknown>
Environment gaps: <missing permissions, data or dependencies>
Decision: <reproducible / needs verification / HOLD>
Status: documented example; audit execution: Unknown.

# DEFENSE_NARRATIVE.md

Audience: <reviewer or evaluator>
Problem: <bounded problem and user>
Claim: <what this capstone slice demonstrates>
Path: <three to five actions and expected signals>
Evidence anchors: <files, commands or notes>
Known limits: <Unknowns and unsupported cases>
Decision requested: <GO / HOLD / feedback>
Status: documented example; defense outcome: Unknown.

# REMEDIATION_BACKLOG.md

Source review: <mentor/reviewer note or Unknown>

| Priority | Finding | Evidence | Owner | Acceptance signal | Status |
| --- | --- | --- | --- | --- | --- |
| Must fix | <blocking gap> | <anchor or Unknown> | <role or Unknown> | <observable check> | Needs verification |
| Should fix | <quality improvement> | <anchor or Unknown> | <role or Unknown> | <observable check> | Planned documented example |
| Later | <deferred improvement> | <reason> | <role or Unknown> | <future signal> | Deferred |

Boundary: this backlog does not prove mentor approval or completed remediation.

# PORTFOLIO_PACKAGE.md

Title: <capstone name>
Problem and audience: <bounded context>
Role/contribution: <verified contribution or Unknown>
Core flow: <short observable scenario>
Selected evidence: <submission, demo, checks and review anchors>
Evaluation: <rubric summary or Unknown>
Review outcome: <observed decision or Unknown>
Limitations: <unsupported claims and open questions>
Next step: <remediation item or bounded follow-up>
Status: documented example; portfolio publication and external validation: Unknown.

# AI_NATIVE_POSITIONING.md\n\nProblem: <bounded problem or workflow>\nOwnership: <decisions and responsibilities>\nAI assistance: <where tools helped>\nEvidence: <verified source or Unknown>\nBoundary: <claims not supported by this record>\nStatus: documented example; hiring outcome: Unknown.\n

# PROOF_OF_WORK_BANK.md\n\n## Entry\n- Claim: <one concrete statement>\n- Source: <file, diff, command, or review note>\n- Signal: <observed result or Unknown>\n- Contribution: <what I owned>\n- Boundary: <what this does not prove>\n\nStatus: documented example; external validation: Unknown.\n

# CAREER_NARRATIVE.md\n\nLevel frame: <Junior / Middle / Senior>\nContext: <problem and audience>\nOwnership: <decisions and contribution>\nTrade-offs: <choice and deferred alternative>\nEvidence: <anchors or Unknown>\nNext step: <bounded follow-up>\nStatus: documented example; seniority validation: Unknown.\n

# AI_NATIVE_RESUME.md\n\nHeadline: <bounded capability>\nEvidence-backed outcome: <observable signal or Unknown>\nContribution: <what I owned>\nRepository link: <verified link or Unknown>\nProfile summary: <consistent narrative>\nAI disclosure: <transparent assistance boundary>\nStatus: documented example; review and hiring outcome: Unknown.\n

# PORTFOLIO_DEFENSE.md\n\nProblem: <bounded problem and audience>\nMy decisions: <framing, trade-offs, and checks>\nAI assistance: <generated or assisted parts>\nEvidence path: <anchors and expected signals>\nUnknowns: <open questions>\nDecision requested: <feedback / next check>\nStatus: documented example; interview and hiring outcome: Unknown.\n

# APPLICATION_TRACKER.md\n\n| Role | Source | Status | Next action | Date | Evidence |\n| --- | --- | --- | --- | --- | --- |\n| <role> | <URL or Unknown> | Research / Draft / Ready for review / Unknown | <one bounded action> | <date or Unknown> | <anchor or Unknown> |\n\nPrivacy: do not store credentials, secrets or unnecessary personal data.\nBoundary: tracker status does not prove submission, interview, response or employment.\nStatus: documented example.\n

# ASSESSMENT_FEEDBACK_LOOP.md\n\nAssessment/source: <prompt, review note or Unknown>\nTimebox and allowed tools: <bounded constraints>\nExpected signal: <observable criterion>\nObserved result: <result or Unknown>\nFeedback status: received / requested / Unknown\nGap: <verified finding or personal hypothesis>\nNext action: <one remediation step>\nBoundary: assessment, interview, pass/fail and hiring outcome are Unknown unless separately evidenced.\nStatus: documented example.\n