From 0d7410b3ceb7ac25673dfd1da0fccf82deef7e50 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:45:50 -0500
Subject: [PATCH 01/21] chore(local): normalize expand regex escaping


From 9e91036f481181c5c563330d34081ed10a933a2f Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:53:15 -0500
Subject: [PATCH 02/21] feat(p01-t01): add backlog scaffold initializer

---
 .../cli/src/commands/backlog/init.test.ts     | 64 +++++++++++++++
 packages/cli/src/commands/backlog/init.ts     | 78 +++++++++++++++++++
 2 files changed, 142 insertions(+)
 create mode 100644 packages/cli/src/commands/backlog/init.test.ts
 create mode 100644 packages/cli/src/commands/backlog/init.ts

diff --git a/packages/cli/src/commands/backlog/init.test.ts b/packages/cli/src/commands/backlog/init.test.ts
new file mode 100644
index 000000000..4b989f8e7
--- /dev/null
+++ b/packages/cli/src/commands/backlog/init.test.ts
@@ -0,0 +1,64 @@
+import { access, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { initializeBacklog } from './init';
+
+describe('initializeBacklog', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      tempDirs.map((dir) => rm(dir, { recursive: true, force: true })),
+    );
+    tempDirs.length = 0;
+  });
+
+  it('creates the backlog directories and starter markdown files', async () => {
+    const backlogRoot = await mkdtemp(join(tmpdir(), 'oat-backlog-init-'));
+    tempDirs.push(backlogRoot);
+
+    await initializeBacklog(backlogRoot);
+
+    await expect(access(join(backlogRoot, 'items'))).resolves.toBeUndefined();
+    await expect(
+      access(join(backlogRoot, 'archived')),
+    ).resolves.toBeUndefined();
+
+    const index = await readFile(join(backlogRoot, 'index.md'), 'utf8');
+    expect(index).toContain('# OAT Backlog Index');
+    expect(index).toContain('## Curated Overview');
+    expect(index).toContain('<!-- OAT BACKLOG-INDEX -->');
+    expect(index).toContain('<!-- END OAT BACKLOG-INDEX -->');
+    expect(index).toContain('## Notes');
+
+    const completed = await readFile(join(backlogRoot, 'completed.md'), 'utf8');
+    expect(completed).toContain('# OAT Backlog Completed');
+    expect(completed).toContain('## Entry Format');
+    expect(completed).toContain('## Completed Items');
+  });
+
+  it('does not overwrite existing backlog markdown files on rerun', async () => {
+    const backlogRoot = await mkdtemp(join(tmpdir(), 'oat-backlog-init-'));
+    tempDirs.push(backlogRoot);
+
+    await initializeBacklog(backlogRoot);
+
+    const indexPath = join(backlogRoot, 'index.md');
+    const completedPath = join(backlogRoot, 'completed.md');
+    const customIndex = '# Custom Backlog Index\n';
+    const customCompleted = '# Custom Completed\n';
+
+    await writeFile(indexPath, customIndex, 'utf8');
+    await writeFile(completedPath, customCompleted, 'utf8');
+
+    await initializeBacklog(backlogRoot);
+
+    await expect(readFile(indexPath, 'utf8')).resolves.toBe(customIndex);
+    await expect(readFile(completedPath, 'utf8')).resolves.toBe(
+      customCompleted,
+    );
+  });
+});
diff --git a/packages/cli/src/commands/backlog/init.ts b/packages/cli/src/commands/backlog/init.ts
new file mode 100644
index 000000000..2ef95a1a3
--- /dev/null
+++ b/packages/cli/src/commands/backlog/init.ts
@@ -0,0 +1,78 @@
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const INDEX_START = '<!-- OAT BACKLOG-INDEX -->';
+const INDEX_END = '<!-- END OAT BACKLOG-INDEX -->';
+
+const EMPTY_MANAGED_TABLE = [
+  INDEX_START,
+  '',
+  '| ID | Title | Status | Priority | Scope | Estimate |',
+  '| --- | --- | --- | --- | --- | --- |',
+  '| _No backlog items yet_ | - | - | - | - | - |',
+  '',
+  INDEX_END,
+].join('\n');
+
+const STARTER_INDEX = [
+  '# OAT Backlog Index',
+  '',
+  '> Generated backlog table lives inside the managed section below. Keep curated narrative updates in the overview section so CLI regeneration stays safe.',
+  '',
+  '## Curated Overview',
+  '',
+  '- Add brief narrative summaries here as backlog items are created and reprioritized.',
+  '',
+  EMPTY_MANAGED_TABLE,
+  '',
+  '## Notes',
+  '',
+  '- Active item files live in `backlog/items/`',
+  '- Archived item files live in `backlog/archived/`',
+  '- Historical completions are summarized in `backlog/completed.md`',
+  '',
+].join('\n');
+
+const STARTER_COMPLETED = [
+  '# OAT Backlog Completed',
+  '',
+  '> Summary archive for completed backlog work. Keep newest entries first. Use `backlog/archived/` for full file-per-item historical records when a completed item still needs rich context.',
+  '',
+  '## Entry Format',
+  '',
+  '- `YYYY-MM-DD — bl-XXXX — Title — one-line outcome summary`',
+  '',
+  '## Completed Items',
+  '',
+].join('\n');
+
+async function writeFileIfMissing(
+  filePath: string,
+  content: string,
+): Promise<void> {
+  try {
+    await access(filePath);
+  } catch (error) {
+    const code =
+      error && typeof error === 'object' && 'code' in error
+        ? String(error.code)
+        : null;
+
+    if (code !== 'ENOENT') {
+      throw error;
+    }
+
+    await writeFile(filePath, content, 'utf8');
+  }
+}
+
+export async function initializeBacklog(backlogRoot: string): Promise<void> {
+  await mkdir(join(backlogRoot, 'items'), { recursive: true });
+  await mkdir(join(backlogRoot, 'archived'), { recursive: true });
+
+  await writeFileIfMissing(join(backlogRoot, 'index.md'), STARTER_INDEX);
+  await writeFileIfMissing(
+    join(backlogRoot, 'completed.md'),
+    STARTER_COMPLETED,
+  );
+}

From 2c6b6fceddd38c5b48b8611b0550dd8c8a27ba30 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:53:46 -0500
Subject: [PATCH 03/21] chore(oat): update tracking artifacts for p01-t01

---
 .../backlog-init-command/implementation.md    | 234 ++++++++++++++++++
 .../shared/backlog-init-command/plan.md       | 219 ++++++++++++++++
 .../shared/backlog-init-command/state.md      |  52 ++++
 3 files changed, 505 insertions(+)
 create mode 100644 .oat/projects/shared/backlog-init-command/implementation.md
 create mode 100644 .oat/projects/shared/backlog-init-command/plan.md
 create mode 100644 .oat/projects/shared/backlog-init-command/state.md

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
new file mode 100644
index 000000000..6e850240f
--- /dev/null
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -0,0 +1,234 @@
+---
+oat_status: in_progress
+oat_ready_for: null
+oat_blockers: []
+oat_last_updated: 2026-03-20
+oat_current_task_id: p01-t02
+oat_generated: false
+---
+
+# Implementation: backlog-init-command
+
+**Started:** 2026-03-20
+**Last Updated:** 2026-03-20
+
+> This document is used to resume interrupted implementation sessions.
+>
+> Conventions:
+>
+> - `oat_current_task_id` always points at the **next plan task to do** (not the last completed task).
+> - When all plan tasks are complete, set `oat_current_task_id: null`.
+> - Reviews are **not** plan tasks. Track review status in `plan.md` under `## Reviews` (e.g., `| final | code | passed | ... |`).
+> - Keep phase/task statuses consistent with the Progress Overview table so restarts resume correctly.
+> - Before running the `oat-project-pr-final` skill, ensure `## Final Summary (for PR/docs)` is filled with what was actually implemented.
+
+## Progress Overview
+
+| Phase   | Status      | Tasks | Completed |
+| ------- | ----------- | ----- | --------- |
+| Phase 1 | in_progress | 2     | 1/2       |
+| Phase 2 | pending     | 1     | 0/1       |
+
+**Total:** 1/3 tasks completed
+
+---
+
+## Phase 1: Backlog Scaffold Command
+
+**Status:** in_progress
+**Started:** 2026-03-20
+
+### Phase Summary (fill when phase is complete)
+
+**Outcome (what changed):**
+
+- Pending implementation
+
+**Key files touched:**
+
+- `packages/cli/src/commands/backlog/` - new scaffold command and tests
+
+**Verification:**
+
+- Run: pending
+- Result: pending
+
+**Notes / Decisions:**
+
+- Keep this phase limited to the explicit backlog scaffold entry point and command wiring.
+
+### Task p01-t01: Implement backlog scaffold initializer
+
+**Status:** completed
+**Commit:** 1db39dd6
+
+**Outcome (required when completed):**
+
+- Added an `initializeBacklog()` helper that creates the backlog root, `items/`, and `archived/` directories.
+- Seeded canonical starter content for `index.md` and `completed.md` while preserving existing files on rerun.
+- Added targeted tests for fresh-root scaffolding and rerun idempotence.
+
+**Files changed:**
+
+- `packages/cli/src/commands/backlog/init.ts` - added the backlog scaffold helper and starter content
+- `packages/cli/src/commands/backlog/init.test.ts` - added focused coverage for scaffold creation and no-overwrite reruns
+
+**Verification:**
+
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
+- Result: Pass; both initializer tests passed after adding the helper implementation
+
+**Notes / Decisions:**
+
+- Seeded the managed index section with the same empty-table shape used by the existing backlog index regeneration flow.
+- Treated `index.md` and `completed.md` as create-if-missing files so reruns do not erase curated edits.
+
+---
+
+### Task p01-t02: Wire `oat backlog init` into the CLI
+
+**Status:** pending
+**Commit:** -
+
+**Notes:**
+
+- Register the subcommand under `oat backlog`.
+- Add help snapshot coverage for the new command surface.
+
+---
+
+## Phase 2: Compatibility Coverage
+
+**Status:** pending
+**Started:** -
+
+### Task p02-t01: Add regression coverage for scaffold compatibility
+
+**Status:** pending
+**Commit:** -
+
+**Notes:**
+
+- Prove a freshly scaffolded backlog root works with `regenerate-index`.
+- Preserve curated overview content across repeated `init` runs.
+
+---
+
+## Orchestration Runs
+
+> This section is used by `oat-project-subagent-implement` to log parallel execution runs.
+> Each run appends a new subsection — never overwrite prior entries.
+> For single-thread execution (via `oat-project-implement`), this section remains empty.
+
+<!-- orchestration-runs-start -->
+<!-- orchestration-runs-end -->
+
+---
+
+## Implementation Log
+
+Chronological log of implementation progress.
+
+### 2026-03-20
+
+**Session Start:** planning
+
+- [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
+- [ ] p01-t02: Wire `oat backlog init` into the CLI - pending
+- [ ] p02-t01: Add regression coverage for scaffold compatibility - pending
+
+**What changed (high level):**
+
+- Scaffolded the quick-mode project and captured discovery for an explicit `oat backlog init` command.
+- Generated an execution-ready three-task plan focused on CLI scaffolding and compatibility coverage.
+- Implemented the backlog scaffold helper and tests for fresh-root creation plus rerun idempotence.
+
+**Decisions:**
+
+- Keep the feature backlog-scoped and explicit; do not update `oat-pjm-*` skills in this project.
+- Skip lightweight design because the request is well-understood and does not have unresolved architecture questions.
+
+**Follow-ups / TODO:**
+
+- Confirm exact starter content in `index.md` and `completed.md` against the current canonical backlog structure during implementation.
+
+**Blockers:**
+
+- None
+
+**Session End:** planning complete
+
+---
+
+### 2026-03-20
+
+**Session Start:** implementation
+
+- [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
+- [ ] p01-t02: Wire `oat backlog init` into the CLI - next
+
+**What changed (high level):**
+
+- Added the reusable backlog scaffold helper that seeds canonical starter files.
+- Added targeted tests proving the helper creates the directories and preserves existing file content on rerun.
+
+**Decisions:**
+
+- Use create-if-missing semantics for `index.md` and `completed.md` so the future command is idempotent by default.
+
+**Follow-ups / TODO:**
+
+- Wire the helper into the `oat backlog` command group and expose help text next.
+
+**Blockers:**
+
+- None
+
+**Session End:** task complete
+
+---
+
+## Deviations from Plan
+
+Document any deviations from the original plan.
+
+| Task | Planned | Actual | Reason |
+| ---- | ------- | ------ | ------ |
+| -    | -       | -      | -      |
+
+## Test Results
+
+Track test execution during implementation.
+
+| Phase | Tests Run | Passed | Failed | Coverage |
+| ----- | --------- | ------ | ------ | -------- |
+| 1     | -         | -      | -      | -        |
+| 2     | -         | -      | -      | -        |
+
+## Final Summary (for PR/docs)
+
+**What shipped:**
+
+- Pending implementation
+
+**Behavioral changes (user-facing):**
+
+- Pending implementation
+
+**Key files / modules:**
+
+- Pending implementation
+
+**Verification performed:**
+
+- Pending implementation
+
+**Design deltas (if any):**
+
+- None expected
+
+## References
+
+- Plan: `plan.md`
+- Design: `design.md`
+- Spec: `spec.md`
diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
new file mode 100644
index 000000000..114f0b18c
--- /dev/null
+++ b/.oat/projects/shared/backlog-init-command/plan.md
@@ -0,0 +1,219 @@
+---
+oat_status: complete
+oat_ready_for: oat-project-implement
+oat_blockers: []
+oat_last_updated: 2026-03-20
+oat_phase: plan
+oat_phase_status: complete
+oat_plan_hill_phases: ['p02'] # phases to pause AFTER completing (empty = every phase)
+oat_plan_source: quick # spec-driven | quick | imported
+oat_import_reference: null # e.g., references/imported-plan.md
+oat_import_source_path: null # original source path provided by user
+oat_import_provider: null # codex | cursor | claude | null
+oat_generated: false
+---
+
+# Implementation Plan: backlog-init-command
+
+> Execute this plan using `oat-project-implement` (sequential) or `oat-project-subagent-implement` (parallel), with phase checkpoints and review gates.
+
+**Goal:** Add an explicit, idempotent `oat backlog init` command that scaffolds the canonical local backlog directory structure and starter files for repositories that do not already have them.
+
+**Architecture:** Extend the existing backlog CLI group with a scaffold command that resolves a backlog root, creates the missing directories and starter markdown files, and leaves existing curated content untouched on rerun. Use the current backlog file structure and managed index markers as the source of truth.
+
+**Tech Stack:** TypeScript ESM, Commander, Node.js 22, Vitest, pnpm workspaces
+
+**Commit Convention:** `{type}({scope}): {description}` - e.g., `feat(p01-t01): add backlog scaffold initializer`
+
+## Planning Checklist
+
+- [x] Deferred HiLL checkpoint confirmation to `oat-project-implement`
+
+---
+
+## Phase 1: Backlog Scaffold Command
+
+Implement the new scaffold command and the filesystem helper it relies on.
+
+### Task p01-t01: Implement backlog scaffold initializer
+
+**Files:**
+
+- Create: `packages/cli/src/commands/backlog/init.ts`
+- Create: `packages/cli/src/commands/backlog/init.test.ts`
+
+**Step 1: Write test (RED)**
+
+Add focused tests for a fresh backlog root that assert:
+
+- `items/` and `archived/` are created
+- `index.md` is seeded with:
+  - `# OAT Backlog Index`
+  - `## Curated Overview`
+  - `<!-- OAT BACKLOG-INDEX -->` / `<!-- END OAT BACKLOG-INDEX -->`
+  - `## Notes`
+- `completed.md` is seeded with:
+  - `# OAT Backlog Completed`
+  - `## Entry Format`
+  - `## Completed Items`
+- rerunning the initializer does not overwrite existing file contents
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
+Expected: Test fails (RED)
+
+**Step 2: Implement (GREEN)**
+
+Implement an initializer that creates the backlog root when missing and writes starter content only for files that do not yet exist. Preserve any existing `index.md` or `completed.md` content on rerun.
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
+Expected: Test passes (GREEN)
+
+**Step 3: Refactor**
+
+Extract reusable starter content/constants as needed so the command remains readable and future content drift is easy to manage.
+
+**Step 4: Verify**
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
+Expected: No errors
+
+**Step 5: Commit**
+
+```bash
+git add packages/cli/src/commands/backlog/init.ts packages/cli/src/commands/backlog/init.test.ts
+git commit -m "feat(p01-t01): add backlog scaffold initializer"
+```
+
+---
+
+### Task p01-t02: Wire `oat backlog init` into the CLI
+
+**Files:**
+
+- Modify: `packages/cli/src/commands/backlog/index.ts`
+- Modify: `packages/cli/src/commands/help-snapshots.test.ts`
+
+**Step 1: Write test (RED)**
+
+Add or update help snapshot coverage so:
+
+- `oat backlog --help` lists `init`
+- `oat backlog init --help` documents the command and `--backlog-root <path>`
+
+**Step 2: Implement (GREEN)**
+
+Register a new `init` subcommand under `createBacklogCommand()` that:
+
+- resolves the backlog root using the same root resolution pattern as the existing backlog commands
+- calls the initializer
+- reports the resulting backlog root in text and JSON modes
+
+**Step 3: Refactor**
+
+Keep shared backlog-root resolution and output behavior consistent with the existing `generate-id` and `regenerate-index` commands.
+
+**Step 4: Verify**
+
+Run: `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
+Expected: Updated snapshots pass
+
+**Step 5: Commit**
+
+```bash
+git add packages/cli/src/commands/backlog/index.ts packages/cli/src/commands/help-snapshots.test.ts
+git commit -m "feat(p01-t02): add backlog init command"
+```
+
+---
+
+## Phase 2: Compatibility Coverage
+
+Prove that the new scaffold works cleanly with the existing backlog command surface and remains safe on rerun.
+
+### Task p02-t01: Add regression coverage for scaffold compatibility
+
+**Files:**
+
+- Modify: `packages/cli/src/commands/backlog/init.test.ts`
+- Modify: `packages/cli/src/commands/backlog/regenerate-index.test.ts`
+
+**Step 1: Write test (RED)**
+
+Add regression coverage that:
+
+- runs the scaffold against an empty backlog root and then successfully regenerates the index
+- verifies the managed table can be rewritten in the seeded `index.md`
+- proves rerunning `init` preserves existing curated overview edits instead of resetting the file
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+Expected: New regression cases fail (RED)
+
+**Step 2: Implement (GREEN)**
+
+Adjust scaffold content or helper behavior as needed so the seeded files are fully compatible with `regenerate-index` and safe for repeated invocation.
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+Expected: Tests pass (GREEN)
+
+**Step 3: Refactor**
+
+Tighten any duplicated test setup or scaffold text helpers while keeping the command contract unchanged.
+
+**Step 4: Verify**
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
+Expected: No errors
+
+**Step 5: Commit**
+
+```bash
+git add packages/cli/src/commands/backlog/init.test.ts packages/cli/src/commands/backlog/regenerate-index.test.ts packages/cli/src/commands/help-snapshots.test.ts
+git commit -m "test(p02-t01): cover backlog init compatibility"
+```
+
+---
+
+## Reviews
+
+{Track reviews here after running the oat-project-review-provide and oat-project-review-receive skills.}
+
+{Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
+
+| Scope  | Type     | Status  | Date | Artifact |
+| ------ | -------- | ------- | ---- | -------- |
+| p01    | code     | pending | -    | -        |
+| p02    | code     | pending | -    | -        |
+| final  | code     | pending | -    | -        |
+| spec   | artifact | pending | -    | -        |
+| design | artifact | pending | -    | -        |
+
+**Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
+
+**Meaning:**
+
+- `received`: review artifact exists (not yet converted into fix tasks)
+- `fixes_added`: fix tasks were added to the plan (work queued)
+- `fixes_completed`: fix tasks implemented, awaiting re-review
+- `passed`: re-review run and recorded as passing (no Critical/Important)
+
+---
+
+## Implementation Complete
+
+**Summary:**
+
+- Phase 1: 2 tasks - add the scaffold initializer and wire `oat backlog init` into the backlog CLI
+- Phase 2: 1 task - add compatibility and idempotence regression coverage
+
+**Total: 3 tasks**
+
+Ready for code review and merge.
+
+---
+
+## References
+
+- Design: `design.md` (required in spec-driven mode; optional in quick/import mode)
+- Spec: `spec.md` (required in spec-driven mode; optional in quick/import mode)
+- Discovery: `discovery.md`
+- Imported Source: `references/imported-plan.md` (when `oat_plan_source: imported`)
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
new file mode 100644
index 000000000..da69d16df
--- /dev/null
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -0,0 +1,52 @@
+---
+oat_current_task: p01-t02
+oat_last_commit: 1db39dd6
+oat_blockers: []
+associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
+oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
+oat_hill_completed: [] # Progress: which HiLL checkpoints have been completed
+oat_parallel_execution: false
+oat_phase: implement # Current phase: discovery | spec | design | plan | implement
+oat_phase_status: in_progress # Status: in_progress | complete
+oat_execution_mode: single-thread # single-thread | subagent-driven
+oat_workflow_mode: quick # spec-driven | quick | import
+oat_workflow_origin: native # native | imported
+oat_docs_updated: null # null | skipped | complete — documentation sync status
+oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
+oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
+oat_project_state_updated: '2026-03-20T21:45:00Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_generated: false
+---
+
+# Project State: backlog-init-command
+
+**Status:** Implementing
+**Started:** 2026-03-20
+**Last Updated:** 2026-03-20
+
+## Current Phase
+
+Implementation in progress
+
+## Artifacts
+
+- **Discovery:** `discovery.md` (complete)
+- **Spec:** N/A (quick mode)
+- **Design:** N/A (quick mode)
+- **Plan:** `plan.md` (complete — 3 tasks across 2 phases)
+- **Implementation:** `implementation.md` (in progress — next task `p01-t02`)
+
+## Progress
+
+- ✓ Discovery complete
+- ✓ Plan complete
+- ✓ `p01-t01` complete
+- ⧗ Executing `p01-t02`
+
+## Blockers
+
+None
+
+## Next Milestone
+
+Complete `p01-t02` and finish phase 1.

From 2c097f9e67011decb230e17285c6fecc608407f7 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:54:50 -0500
Subject: [PATCH 04/21] feat(p01-t02): add backlog init command

---
 packages/cli/src/commands/backlog/index.ts    | 35 ++++++++++++++++
 .../cli/src/commands/help-snapshots.test.ts   | 41 +++++++++++++++++++
 2 files changed, 76 insertions(+)

diff --git a/packages/cli/src/commands/backlog/index.ts b/packages/cli/src/commands/backlog/index.ts
index 33daba856..043e2f065 100644
--- a/packages/cli/src/commands/backlog/index.ts
+++ b/packages/cli/src/commands/backlog/index.ts
@@ -5,12 +5,17 @@ import { readGlobalOptions } from '@commands/shared/shared.utils';
 import { resolveProjectRoot } from '@fs/paths';
 import { Command } from 'commander';
 
+import { initializeBacklog } from './init';
 import { regenerateBacklogIndex } from './regenerate-index';
 import {
   generateUniqueBacklogId,
   readExistingBacklogIds,
 } from './shared/generate-id';
 
+interface InitOptions {
+  backlogRoot?: string;
+}
+
 interface RegenerateIndexOptions {
   backlogRoot?: string;
 }
@@ -22,12 +27,14 @@ interface GenerateIdOptions {
 interface BacklogCommandDependencies {
   buildCommandContext: typeof buildCommandContext;
   resolveProjectRoot: typeof resolveProjectRoot;
+  initializeBacklog: typeof initializeBacklog;
   regenerateBacklogIndex: typeof regenerateBacklogIndex;
 }
 
 const DEFAULT_DEPENDENCIES: BacklogCommandDependencies = {
   buildCommandContext,
   resolveProjectRoot,
+  initializeBacklog,
   regenerateBacklogIndex,
 };
 
@@ -56,6 +63,34 @@ export function createBacklogCommand(
     'Manage file-backed backlog items and indexes',
   );
 
+  cmd
+    .command('init')
+    .description(
+      'Scaffold the canonical backlog directory structure and starter files',
+    )
+    .option(
+      '--backlog-root <path>',
+      'Backlog root directory (defaults to .oat/repo/reference/backlog)',
+    )
+    .action(async (options: InitOptions, command: Command) => {
+      const context = dependencies.buildCommandContext(
+        readGlobalOptions(command),
+      );
+      const backlogRoot = await resolveBacklogRoot(
+        context,
+        options.backlogRoot,
+        dependencies,
+      );
+      await dependencies.initializeBacklog(backlogRoot);
+
+      if (context.json) {
+        context.logger.json({ status: 'ok', backlogRoot });
+      } else {
+        context.logger.info(`Initialized backlog scaffold at ${backlogRoot}`);
+      }
+      process.exitCode = 0;
+    });
+
   cmd
     .command('regenerate-index')
     .description('Regenerate the managed backlog index table')
diff --git a/packages/cli/src/commands/help-snapshots.test.ts b/packages/cli/src/commands/help-snapshots.test.ts
index bcebcd550..d10b43014 100644
--- a/packages/cli/src/commands/help-snapshots.test.ts
+++ b/packages/cli/src/commands/help-snapshots.test.ts
@@ -106,6 +106,47 @@ describe('help output snapshots', () => {
     `);
   });
 
+  it('backlog --help matches snapshot', () => {
+    const program = createRegisteredProgram();
+    const help = getCommandByPath(program, ['backlog']).helpInformation();
+    expect(help).toMatchInlineSnapshot(`
+      "Usage: oat backlog [options] [command]
+
+      Manage file-backed backlog items and indexes
+
+      Options:
+        -h, --help                        display help for command
+
+      Commands:
+        init [options]                    Scaffold the canonical backlog directory
+                                          structure and starter files
+        regenerate-index [options]        Regenerate the managed backlog index table
+        generate-id [options] <filename>  Generate a backlog item identifier from a
+                                          filename seed
+        help [command]                    display help for command
+      "
+    `);
+  });
+
+  it('backlog init --help matches snapshot', () => {
+    const program = createRegisteredProgram();
+    const help = getCommandByPath(program, [
+      'backlog',
+      'init',
+    ]).helpInformation();
+    expect(help).toMatchInlineSnapshot(`
+      "Usage: oat backlog init [options]
+
+      Scaffold the canonical backlog directory structure and starter files
+
+      Options:
+        --backlog-root <path>  Backlog root directory (defaults to
+                               .oat/repo/reference/backlog)
+        -h, --help             display help for command
+      "
+    `);
+  });
+
   it('status --help matches snapshot', () => {
     const program = createRegisteredProgram();
     const help = getCommandByPath(program, ['status']).helpInformation();

From 941980c64c6b5c5fbeff60ac8e77b1d8c3637fe8 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:55:48 -0500
Subject: [PATCH 05/21] chore(oat): update tracking artifacts for p01-t02

---
 .../backlog-init-command/implementation.md    | 87 ++++++++++++++-----
 .../shared/backlog-init-command/state.md      | 14 +--
 2 files changed, 74 insertions(+), 27 deletions(-)

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
index 6e850240f..54fa25000 100644
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -3,7 +3,7 @@ oat_status: in_progress
 oat_ready_for: null
 oat_blockers: []
 oat_last_updated: 2026-03-20
-oat_current_task_id: p01-t02
+oat_current_task_id: p02-t01
 oat_generated: false
 ---
 
@@ -26,36 +26,42 @@ oat_generated: false
 
 | Phase   | Status      | Tasks | Completed |
 | ------- | ----------- | ----- | --------- |
-| Phase 1 | in_progress | 2     | 1/2       |
-| Phase 2 | pending     | 1     | 0/1       |
+| Phase 1 | complete    | 2     | 2/2       |
+| Phase 2 | in_progress | 1     | 0/1       |
 
-**Total:** 1/3 tasks completed
+**Total:** 2/3 tasks completed
 
 ---
 
 ## Phase 1: Backlog Scaffold Command
 
-**Status:** in_progress
+**Status:** complete
 **Started:** 2026-03-20
 
 ### Phase Summary (fill when phase is complete)
 
 **Outcome (what changed):**
 
-- Pending implementation
+- Added the reusable backlog scaffold helper and surfaced it through a new `oat backlog init` CLI command.
+- Documented the new scaffold entry point in the backlog help output and added dedicated help snapshot coverage.
+- Finished the first implementation phase without adding any skill-side auto-init behavior.
 
 **Key files touched:**
 
-- `packages/cli/src/commands/backlog/` - new scaffold command and tests
+- `packages/cli/src/commands/backlog/init.ts` - backlog scaffold helper and starter content
+- `packages/cli/src/commands/backlog/index.ts` - new `backlog init` command wiring
+- `packages/cli/src/commands/backlog/init.test.ts` - initializer coverage
+- `packages/cli/src/commands/help-snapshots.test.ts` - help coverage for the new command surface
 
 **Verification:**
 
-- Run: pending
-- Result: pending
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`; `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
+- Result: Pass; initializer tests and help snapshots both succeeded
 
 **Notes / Decisions:**
 
-- Keep this phase limited to the explicit backlog scaffold entry point and command wiring.
+- Kept the feature backlog-scoped and explicit; no skill auto-scaffold behavior was introduced.
+- Reused the existing backlog root resolution path so all backlog commands share the same lookup semantics.
 
 ### Task p01-t01: Implement backlog scaffold initializer
 
@@ -87,20 +93,35 @@ oat_generated: false
 
 ### Task p01-t02: Wire `oat backlog init` into the CLI
 
-**Status:** pending
-**Commit:** -
+**Status:** completed
+**Commit:** dcb2b50e
 
-**Notes:**
+**Outcome (required when completed):**
+
+- Added `oat backlog init` to the backlog command group with standard text and JSON output.
+- Exposed `--backlog-root <path>` for explicit scaffold targeting when needed.
+- Added help snapshot coverage for both `oat backlog --help` and `oat backlog init --help`.
+
+**Files changed:**
 
-- Register the subcommand under `oat backlog`.
-- Add help snapshot coverage for the new command surface.
+- `packages/cli/src/commands/backlog/index.ts` - wired the new init subcommand into the CLI
+- `packages/cli/src/commands/help-snapshots.test.ts` - added help expectations for the new backlog scaffold command
+
+**Verification:**
+
+- Run: `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
+- Result: Pass; help output matches the updated snapshots
+
+**Notes / Decisions:**
+
+- Used the same `resolveBacklogRoot()` helper as `generate-id` and `regenerate-index` to keep path behavior consistent.
 
 ---
 
 ## Phase 2: Compatibility Coverage
 
-**Status:** pending
-**Started:** -
+**Status:** in_progress
+**Started:** 2026-03-20
 
 ### Task p02-t01: Add regression coverage for scaffold compatibility
 
@@ -134,7 +155,7 @@ Chronological log of implementation progress.
 **Session Start:** planning
 
 - [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
-- [ ] p01-t02: Wire `oat backlog init` into the CLI - pending
+- [x] p01-t02: Wire `oat backlog init` into the CLI - dcb2b50e
 - [ ] p02-t01: Add regression coverage for scaffold compatibility - pending
 
 **What changed (high level):**
@@ -165,7 +186,8 @@ Chronological log of implementation progress.
 **Session Start:** implementation
 
 - [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
-- [ ] p01-t02: Wire `oat backlog init` into the CLI - next
+- [x] p01-t02: Wire `oat backlog init` into the CLI - dcb2b50e
+- [ ] p02-t01: Add regression coverage for scaffold compatibility - next
 
 **What changed (high level):**
 
@@ -178,7 +200,7 @@ Chronological log of implementation progress.
 
 **Follow-ups / TODO:**
 
-- Wire the helper into the `oat backlog` command group and expose help text next.
+- Add regression coverage proving a freshly scaffolded backlog root works with `regenerate-index`.
 
 **Blockers:**
 
@@ -188,6 +210,31 @@ Chronological log of implementation progress.
 
 ---
 
+### 2026-03-20
+
+**Session Start:** implementation
+
+- [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
+- [x] p01-t02: Wire `oat backlog init` into the CLI - dcb2b50e
+- [ ] p02-t01: Add regression coverage for scaffold compatibility - next
+
+**What changed (high level):**
+
+- Added the `oat backlog init` command and documented it in the backlog help surface.
+- Completed phase 1 and rolled directly into phase 2 because the only configured checkpoint is `p02`.
+
+**Decisions:**
+
+- Keep CLI output aligned with the other backlog commands by returning `status` and `backlogRoot` in JSON mode.
+
+**Blockers:**
+
+- None
+
+**Session End:** phase 1 complete
+
+---
+
 ## Deviations from Plan
 
 Document any deviations from the original plan.
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index da69d16df..a4eef6361 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -1,6 +1,6 @@
 ---
-oat_current_task: p01-t02
-oat_last_commit: 1db39dd6
+oat_current_task: p02-t01
+oat_last_commit: dcb2b50e
 oat_blockers: []
 associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
 oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
@@ -14,7 +14,7 @@ oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-20T21:45:00Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-20T21:50:00Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
@@ -34,14 +34,14 @@ Implementation in progress
 - **Spec:** N/A (quick mode)
 - **Design:** N/A (quick mode)
 - **Plan:** `plan.md` (complete — 3 tasks across 2 phases)
-- **Implementation:** `implementation.md` (in progress — next task `p01-t02`)
+- **Implementation:** `implementation.md` (in progress — next task `p02-t01`)
 
 ## Progress
 
 - ✓ Discovery complete
 - ✓ Plan complete
-- ✓ `p01-t01` complete
-- ⧗ Executing `p01-t02`
+- ✓ Phase 1 complete
+- ⧗ Executing `p02-t01`
 
 ## Blockers
 
@@ -49,4 +49,4 @@ None
 
 ## Next Milestone
 
-Complete `p01-t02` and finish phase 1.
+Complete `p02-t01`. Pause after phase 2 per configured checkpoint.

From 10d4d3d1b5438aaa5eb009ab640d241362782014 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:57:03 -0500
Subject: [PATCH 06/21] test(p02-t01): cover backlog init compatibility

---
 .../cli/src/commands/backlog/init.test.ts     | 21 ++++++++++
 .../commands/backlog/regenerate-index.test.ts | 38 +++++++++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/packages/cli/src/commands/backlog/init.test.ts b/packages/cli/src/commands/backlog/init.test.ts
index 4b989f8e7..8ff72272c 100644
--- a/packages/cli/src/commands/backlog/init.test.ts
+++ b/packages/cli/src/commands/backlog/init.test.ts
@@ -61,4 +61,25 @@ describe('initializeBacklog', () => {
       customCompleted,
     );
   });
+
+  it('preserves curated overview edits when the scaffold runs again', async () => {
+    const backlogRoot = await mkdtemp(join(tmpdir(), 'oat-backlog-init-'));
+    tempDirs.push(backlogRoot);
+
+    await initializeBacklog(backlogRoot);
+
+    const indexPath = join(backlogRoot, 'index.md');
+    const index = await readFile(indexPath, 'utf8');
+    const updatedIndex = index.replace(
+      '- Add brief narrative summaries here as backlog items are created and reprioritized.',
+      '- Keep this curated summary.',
+    );
+    await writeFile(indexPath, updatedIndex, 'utf8');
+
+    await initializeBacklog(backlogRoot);
+
+    await expect(readFile(indexPath, 'utf8')).resolves.toContain(
+      '- Keep this curated summary.',
+    );
+  });
 });
diff --git a/packages/cli/src/commands/backlog/regenerate-index.test.ts b/packages/cli/src/commands/backlog/regenerate-index.test.ts
index 7883a35b4..fa5b2a505 100644
--- a/packages/cli/src/commands/backlog/regenerate-index.test.ts
+++ b/packages/cli/src/commands/backlog/regenerate-index.test.ts
@@ -4,6 +4,7 @@ import { join } from 'node:path';
 
 import { afterEach, describe, expect, it } from 'vitest';
 
+import { initializeBacklog } from './init';
 import { regenerateBacklogIndex } from './regenerate-index';
 
 const INDEX_START = '<!-- OAT BACKLOG-INDEX -->';
@@ -140,4 +141,41 @@ describe('regenerateBacklogIndex', () => {
 
     expect(index).toContain('| _No backlog items yet_ | - | - | - | - | - |');
   });
+
+  it('works with a freshly scaffolded backlog root and preserves curated overview content', async () => {
+    const backlogRoot = await mkdtemp(join(tmpdir(), 'oat-backlog-seeded-'));
+    tempDirs.push(backlogRoot);
+
+    await initializeBacklog(backlogRoot);
+
+    const itemsDir = join(backlogRoot, 'items');
+    await writeBacklogItem(itemsDir, 'alpha.md', {
+      id: 'bl-aaaa',
+      title: '"Alpha"',
+      status: 'open',
+      priority: 'high',
+      scope: 'feature',
+      scope_estimate: 'M',
+    });
+
+    const indexPath = join(backlogRoot, 'index.md');
+    const originalIndex = await readFile(indexPath, 'utf8');
+    await writeFile(
+      indexPath,
+      originalIndex.replace(
+        '- Add brief narrative summaries here as backlog items are created and reprioritized.',
+        '- Keep this curated summary.',
+      ),
+      'utf8',
+    );
+
+    await regenerateBacklogIndex(backlogRoot);
+
+    const index = await readFile(indexPath, 'utf8');
+    expect(index).toContain('- Keep this curated summary.');
+    expect(index).toContain('| bl-aaaa | Alpha | open | high | feature | M |');
+    expect(index).not.toContain(
+      '| _No backlog items yet_ | - | - | - | - | - |',
+    );
+  });
 });

From d12cdc85b874bbef20274eb0b32e0789f08b9723 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:58:06 -0500
Subject: [PATCH 07/21] chore(oat): update tracking artifacts for
 implementation complete

---
 .../backlog-init-command/implementation.md    | 89 +++++++++++++++----
 .../shared/backlog-init-command/state.md      | 18 ++--
 2 files changed, 81 insertions(+), 26 deletions(-)

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
index 54fa25000..935c1e103 100644
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -1,9 +1,9 @@
 ---
-oat_status: in_progress
+oat_status: complete
 oat_ready_for: null
 oat_blockers: []
 oat_last_updated: 2026-03-20
-oat_current_task_id: p02-t01
+oat_current_task_id: null
 oat_generated: false
 ---
 
@@ -24,12 +24,12 @@ oat_generated: false
 
 ## Progress Overview
 
-| Phase   | Status      | Tasks | Completed |
-| ------- | ----------- | ----- | --------- |
-| Phase 1 | complete    | 2     | 2/2       |
-| Phase 2 | in_progress | 1     | 0/1       |
+| Phase   | Status   | Tasks | Completed |
+| ------- | -------- | ----- | --------- |
+| Phase 1 | complete | 2     | 2/2       |
+| Phase 2 | complete | 1     | 1/1       |
 
-**Total:** 2/3 tasks completed
+**Total:** 3/3 tasks completed
 
 ---
 
@@ -120,18 +120,33 @@ oat_generated: false
 
 ## Phase 2: Compatibility Coverage
 
-**Status:** in_progress
+**Status:** complete
 **Started:** 2026-03-20
 
 ### Task p02-t01: Add regression coverage for scaffold compatibility
 
-**Status:** pending
-**Commit:** -
+**Status:** completed
+**Commit:** cee41cca
+
+**Outcome (required when completed):**
+
+- Added regression coverage that proves a freshly scaffolded backlog root works with `regenerate-index`.
+- Added a focused idempotence test that preserves curated overview edits across repeated `initializeBacklog()` runs.
+- Confirmed the scaffolded backlog shape was already compatible, so no additional production code changes were needed in this phase.
 
-**Notes:**
+**Files changed:**
+
+- `packages/cli/src/commands/backlog/init.test.ts` - added curated-overview preservation coverage
+- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - added scaffold-compatibility regression coverage
+
+**Verification:**
 
-- Prove a freshly scaffolded backlog root works with `regenerate-index`.
-- Preserve curated overview content across repeated `init` runs.
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
+- Result: Pass; targeted backlog coverage and workspace type-check both succeeded
+
+**Notes / Decisions:**
+
+- The compatibility regressions passed without production changes, which confirmed the phase-1 scaffold content already matches `regenerate-index` expectations.
 
 ---
 
@@ -235,6 +250,34 @@ Chronological log of implementation progress.
 
 ---
 
+### 2026-03-20
+
+**Session Start:** implementation
+
+- [x] p02-t01: Add regression coverage for scaffold compatibility - cee41cca
+
+**What changed (high level):**
+
+- Added compatibility coverage proving a freshly scaffolded backlog root works with the existing index regeneration flow.
+- Added a realistic idempotence test that preserves curated overview edits on rerun.
+- Completed all planned implementation tasks and passed the full verification suite.
+
+**Decisions:**
+
+- Keep phase 2 test-only; the new regressions showed the scaffold contract was already correct.
+
+**Follow-ups / TODO:**
+
+- Request final review before PR work.
+
+**Blockers:**
+
+- None
+
+**Session End:** implementation complete
+
+---
+
 ## Deviations from Plan
 
 Document any deviations from the original plan.
@@ -256,19 +299,31 @@ Track test execution during implementation.
 
 **What shipped:**
 
-- Pending implementation
+- Added an explicit `oat backlog init` command for scaffolding the canonical local backlog directory structure.
+- Added a reusable initializer that creates `items/`, `archived/`, `index.md`, and `completed.md` without overwriting existing backlog files on rerun.
+- Added regression coverage proving the scaffolded backlog shape is compatible with `oat backlog regenerate-index` and preserves curated overview edits.
 
 **Behavioral changes (user-facing):**
 
-- Pending implementation
+- Users can now run `oat backlog init` in a fresh repo to create the starter backlog structure before using other file-backed backlog flows.
+- Re-running the command leaves curated backlog content intact instead of resetting the backlog index or completed summary files.
 
 **Key files / modules:**
 
-- Pending implementation
+- `packages/cli/src/commands/backlog/init.ts` - backlog scaffold helper and starter file content
+- `packages/cli/src/commands/backlog/index.ts` - `oat backlog init` command wiring
+- `packages/cli/src/commands/backlog/init.test.ts` - scaffold creation and idempotence coverage
+- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - scaffold compatibility coverage
 
 **Verification performed:**
 
-- Pending implementation
+- `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
+- `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
+- `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
+- `pnpm test`
+- `pnpm lint`
+- `pnpm type-check`
+- `pnpm build`
 
 **Design deltas (if any):**
 
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index a4eef6361..79cc90b55 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -1,6 +1,6 @@
 ---
-oat_current_task: p02-t01
-oat_last_commit: dcb2b50e
+oat_current_task: null
+oat_last_commit: cee41cca
 oat_blockers: []
 associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
 oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
@@ -14,19 +14,19 @@ oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-20T21:50:00Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-20T22:05:00Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
 # Project State: backlog-init-command
 
-**Status:** Implementing
+**Status:** Awaiting Final Review
 **Started:** 2026-03-20
 **Last Updated:** 2026-03-20
 
 ## Current Phase
 
-Implementation in progress
+Implementation - Tasks complete; awaiting final review.
 
 ## Artifacts
 
@@ -34,14 +34,14 @@ Implementation in progress
 - **Spec:** N/A (quick mode)
 - **Design:** N/A (quick mode)
 - **Plan:** `plan.md` (complete — 3 tasks across 2 phases)
-- **Implementation:** `implementation.md` (in progress — next task `p02-t01`)
+- **Implementation:** `implementation.md` (complete — all planned tasks finished)
 
 ## Progress
 
 - ✓ Discovery complete
 - ✓ Plan complete
-- ✓ Phase 1 complete
-- ⧗ Executing `p02-t01`
+- ✓ Implementation tasks complete
+- ⧗ Awaiting final review
 
 ## Blockers
 
@@ -49,4 +49,4 @@ None
 
 ## Next Milestone
 
-Complete `p02-t01`. Pause after phase 2 per configured checkpoint.
+Run final review for the completed implementation.

From fcf82bf11336961a8cbbd0dcb63d00fb1e44676d Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 17:59:24 -0500
Subject: [PATCH 08/21] chore(oat): add discovery artifact for
 backlog-init-command

---
 .../shared/backlog-init-command/discovery.md  | 120 ++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 .oat/projects/shared/backlog-init-command/discovery.md

diff --git a/.oat/projects/shared/backlog-init-command/discovery.md b/.oat/projects/shared/backlog-init-command/discovery.md
new file mode 100644
index 000000000..1f92ec207
--- /dev/null
+++ b/.oat/projects/shared/backlog-init-command/discovery.md
@@ -0,0 +1,120 @@
+---
+oat_status: complete
+oat_ready_for: oat-project-plan
+oat_blockers: []
+oat_last_updated: 2026-03-20
+oat_generated: false
+---
+
+# Discovery: backlog-init-command
+
+## Initial Request
+
+Add an explicit backlog scaffold CLI command for repositories that have OAT installed but do not yet have the file-backed backlog structure under `.oat/repo/reference/backlog/`. The immediate trigger was trying to use the new project-management flow in a fresh repo and finding that the backlog directories and starter files did not exist.
+
+## Clarifying Questions
+
+### Question 1: Scope of the fix
+
+**Q:** Should the fix include automatic skill behavior changes, or stay at the CLI layer?
+**A:** Keep it to a new CLI command for now and do not update `oat-pjm-*` skills.
+**Decision:** This project will add `oat backlog init` only. Skill behavior stays unchanged.
+
+### Question 2: Future PM direction
+
+**Q:** Should the local backlog scaffold be treated as mandatory project-management initialization?
+**A:** Not yet. Future Linear/Jira-backed project management may not need a local scaffold at all.
+**Decision:** Keep the command backlog-scoped and explicit. Do not introduce PJM-specific or automatic initialization semantics in this task.
+
+## Options Considered
+
+### Option A: Explicit `oat backlog init` command
+
+**Description:** Add a dedicated backlog CLI subcommand that creates the canonical backlog directories and starter markdown files on demand.
+
+**Pros:**
+
+- Keeps the setup behavior explicit and discoverable.
+- Avoids coupling local-only setup assumptions into skills that may later support remote PM flows.
+- Can be reused by any backlog-related workflow, not just add-item flows.
+
+**Cons:**
+
+- Requires users to learn one additional setup command.
+
+**Chosen:** A
+
+**Summary:** Use an explicit, idempotent `oat backlog init` command as the initial fix. It solves the immediate onboarding gap without overcommitting to a local-only PM model.
+
+### Option B: Auto-scaffold from skills or other backlog commands
+
+**Description:** Detect a missing backlog scaffold at runtime and create it implicitly from `oat-pjm-add-backlog-item` or other backlog operations.
+
+**Pros:**
+
+- Reduces manual setup steps for first-time users.
+- Can feel smoother in purely local workflows.
+
+**Cons:**
+
+- Bakes local scaffold assumptions into higher-level flows prematurely.
+- Makes repo mutations less explicit.
+- Risks awkward behavior when future remote PM integrations do not want the same local scaffold.
+
+**Chosen:** Not now
+
+**Summary:** This remains a reasonable future enhancement, but it is intentionally deferred until the local-vs-remote PM model is clearer.
+
+## Key Decisions
+
+1. **Entry point:** Add `oat backlog init` as a first-class CLI command under the existing backlog command group.
+2. **Scope boundary:** Do not update `oat-pjm-add-backlog-item` or other skills in this project.
+3. **Scaffold behavior:** The command should create the canonical backlog directory structure and starter files, and be safe to rerun without clobbering existing curated content.
+
+## Constraints
+
+- This is a new follow-on task after the prior project-management backlog work was already merged.
+- The solution should not assume local file-backed backlog setup is always required for future project-management integrations.
+- The command must fit the existing backlog CLI surface and testing conventions.
+
+## Success Criteria
+
+- `oat backlog init` creates `.oat/repo/reference/backlog/`, `items/`, `archived/`, `index.md`, and `completed.md` when they are missing.
+- The generated starter files use the existing managed index markers and starter sections expected by current backlog tooling.
+- Re-running the command is idempotent and does not overwrite existing curated backlog content.
+- Freshly scaffolded backlog roots work with existing backlog commands such as `oat backlog regenerate-index`.
+
+## Out of Scope
+
+- Automatic scaffold creation from `oat-pjm-*` skills or other backlog commands.
+- Any remote Linear/Jira synchronization or project-management integration changes.
+- Reworking the broader project-management onboarding flow beyond this explicit command.
+
+## Deferred Ideas
+
+- Auto-initialize the backlog scaffold from add-item or review flows once the local-vs-remote PM contract is clearer.
+- Introduce a broader PM initialization story later if remote-backed project-management still benefits from partial local scaffolding.
+
+## Open Questions
+
+- **Future PM model:** Whether later Linear/Jira-backed flows should reuse this local scaffold, partially reuse it, or bypass it entirely.
+
+## Assumptions
+
+- The canonical starter content for `index.md` and `completed.md` should match the current file-backed backlog structure already used in this repo.
+- A backlog-scoped command is the cleanest current entry point because the missing assets live under `.oat/repo/reference/backlog/`, not inside the installed skill pack.
+
+## Risks
+
+- **Scope creep toward full PM setup:** The command could grow into a broader local project-management initializer.
+  - **Likelihood:** Medium
+  - **Impact:** Medium
+  - **Mitigation Ideas:** Keep the command narrowly scoped to backlog files and directories only.
+- **Starter-content drift:** The scaffolded `index.md` and `completed.md` could diverge from the current canonical backlog structure over time.
+  - **Likelihood:** Medium
+  - **Impact:** Medium
+  - **Mitigation Ideas:** Add focused tests that assert the expected managed markers and starter sections.
+
+## Next Steps
+
+Proceed directly to `plan.md`. The request is well-understood, scoped to a single CLI feature, and does not need a separate lightweight design step.

From f0fa3393fb7921885d6ca040f1f4a6b7805f403d Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 18:15:00 -0500
Subject: [PATCH 09/21] chore(oat): record final review artifact

---
 .../shared/backlog-init-command/plan.md       | 14 ++--
 .../reviews/final-review-2026-03-20.md        | 72 +++++++++++++++++++
 2 files changed, 79 insertions(+), 7 deletions(-)
 create mode 100644 .oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md

diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
index 114f0b18c..c38622386 100644
--- a/.oat/projects/shared/backlog-init-command/plan.md
+++ b/.oat/projects/shared/backlog-init-command/plan.md
@@ -179,13 +179,13 @@ git commit -m "test(p02-t01): cover backlog init compatibility"
 
 {Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
 
-| Scope  | Type     | Status  | Date | Artifact |
-| ------ | -------- | ------- | ---- | -------- |
-| p01    | code     | pending | -    | -        |
-| p02    | code     | pending | -    | -        |
-| final  | code     | pending | -    | -        |
-| spec   | artifact | pending | -    | -        |
-| design | artifact | pending | -    | -        |
+| Scope  | Type     | Status   | Date       | Artifact                           |
+| ------ | -------- | -------- | ---------- | ---------------------------------- |
+| p01    | code     | pending  | -          | -                                  |
+| p02    | code     | pending  | -          | -                                  |
+| final  | code     | received | 2026-03-20 | reviews/final-review-2026-03-20.md |
+| spec   | artifact | pending  | -          | -                                  |
+| design | artifact | pending  | -          | -                                  |
 
 **Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
 
diff --git a/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md b/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md
new file mode 100644
index 000000000..cb238bbe7
--- /dev/null
+++ b/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md
@@ -0,0 +1,72 @@
+---
+oat_generated: true
+oat_generated_at: 2026-03-20
+oat_review_scope: final
+oat_review_type: code
+oat_project: /Users/thomas.stang/Code/open-agent-toolkit/.oat/projects/shared/backlog-init-command
+---
+
+# Code Review: final
+
+**Reviewed:** 2026-03-20
+**Scope:** Final code review for `a9e5cd84f298baf8bb61214bc4ba85db03250d19..HEAD` in quick mode (`p01-t01`, `p01-t02`, `p02-t01`)
+**Files reviewed:** 9
+**Commits:** `a9e5cd84f298baf8bb61214bc4ba85db03250d19..HEAD` (8 commits in scope)
+
+## Summary
+
+I reviewed the quick-mode artifacts (`discovery.md`, `plan.md`, `implementation.md`, `state.md`) and the scoped CLI/test changes. The feature is mostly aligned with the discovery and plan, but the scaffold currently omits tracked placeholders for the empty `items/` and `archived/` directories, which means a freshly initialized backlog does not survive a commit/clone round-trip and `oat backlog regenerate-index` then fails with `ENOENT`. I also found a command-level verification gap: the helper is tested, but the actual `oat backlog init` action path and its text/JSON output contract are not covered by automated tests.
+
+## Findings
+
+### Critical
+
+- **Empty backlog directories are not persisted in git, breaking cloned scaffolds** (`packages/cli/src/commands/backlog/init.ts:69`)
+  - Issue: `initializeBacklog()` creates `items/` and `archived/` as empty directories but does not seed tracked placeholders such as `.gitkeep`. In practice, `oat backlog init` only leaves `index.md` and `completed.md` as tracked files; after committing and cloning that repo, the empty directories disappear and `oat backlog regenerate-index` fails with `ENOENT` because `.oat/repo/reference/backlog/items` is gone. That violates the quick-mode goal of creating the canonical local backlog scaffold and the success criterion that freshly scaffolded backlogs work with existing backlog commands.
+  - Fix: Create `items/.gitkeep` and `archived/.gitkeep` when seeding a fresh scaffold, without overwriting existing directory contents. Add a regression test that proves a committed/cloned initialized backlog still has the canonical directory shape and that `oat backlog regenerate-index` succeeds without rerunning `oat backlog init`.
+  - Requirement: Discovery success criteria "creates `.oat/repo/reference/backlog/`, `items/`, `archived/`, `index.md`, and `completed.md`" and "Freshly scaffolded backlog roots work with existing backlog commands such as `oat backlog regenerate-index`"
+
+### Important
+
+- **`oat backlog init` command wiring and output contract are untested** (`packages/cli/src/commands/backlog/index.ts:66`)
+  - Issue: The scoped tests exercise `initializeBacklog()` directly and cover help snapshots, but nothing executes the actual Commander action added in `createBacklogCommand()`. That leaves default root resolution, `--backlog-root`, exit-code behavior, and the plan-required text/JSON output contract unverified. This repo already uses command-level harness tests for comparable CLI surfaces, so the omission is notable.
+  - Fix: Add a command-level test file for the backlog command group that runs `backlog init` through Commander with injected dependencies and asserts default root resolution, `--backlog-root` override behavior, text output, JSON payload `{ status: 'ok', backlogRoot }`, and `process.exitCode`.
+
+### Minor
+
+None
+
+## Requirements/Design Alignment
+
+**Evidence sources used:** `discovery.md`, `plan.md`, `implementation.md`, `state.md`, `packages/cli/src/commands/backlog/index.ts`, `packages/cli/src/commands/backlog/init.ts`, `packages/cli/src/commands/backlog/init.test.ts`, `packages/cli/src/commands/backlog/regenerate-index.test.ts`, `packages/cli/src/commands/help-snapshots.test.ts`
+
+**Design alignment:** Not applicable (`design.md` is not present for quick mode).
+
+### Requirements Coverage
+
+| Requirement                                                                                         | Status      | Notes                                                                                                                                                           |
+| --------------------------------------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Add an explicit `oat backlog init` subcommand under the backlog CLI group                           | implemented | Registered in `createBacklogCommand()` and exposed in help snapshots.                                                                                           |
+| Create the canonical backlog scaffold when missing                                                  | partial     | Root, `items/`, `archived/`, `index.md`, and `completed.md` are created, but the empty directories are not trackable in git because no placeholders are seeded. |
+| Seed starter files with the managed index markers and expected starter sections                     | implemented | `index.md` and `completed.md` starter content matches the current backlog headings and marker contract.                                                         |
+| Re-running the scaffold must be idempotent and preserve curated content                             | implemented | `writeFileIfMissing()` keeps existing file contents intact; helper tests cover rerun preservation.                                                              |
+| Freshly scaffolded backlogs must work with existing commands such as `oat backlog regenerate-index` | partial     | Works in a temp directory before commit, but a committed/cloned empty backlog loses `items/` and then `regenerate-index` fails until `init` is rerun.           |
+| `oat backlog init` should report the backlog root in text and JSON modes                            | implemented | The action logs both formats, but there is no command-level regression coverage for this contract yet.                                                          |
+
+### Extra Work (not in declared requirements)
+
+None
+
+## Verification Commands
+
+Run these to verify the implementation:
+
+```bash
+pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts
+pnpm type-check
+tmp=$(mktemp -d) && repo="$tmp/repo" && clone="$tmp/clone" && git init -q "$repo" && (cd "$repo" && git config user.email review@example.com && git config user.name reviewer) && pnpm run cli -- --cwd "$repo" backlog init && (cd "$repo" && git add . && git commit -qm init) && git clone -q "$repo" "$clone" && pnpm run cli -- --cwd "$clone" backlog regenerate-index
+```
+
+## Recommended Next Step
+
+Run the `oat-project-review-receive` skill to convert findings into plan tasks.

From ca02228acfd4dd36371a2f897ea01fdf2aa1b8c3 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 18:20:51 -0500
Subject: [PATCH 10/21] chore(oat): queue final review fixes for
 backlog-init-command

---
 .../backlog-init-command/implementation.md    | 78 ++++++++++++++++-
 .../shared/backlog-init-command/plan.md       | 84 +++++++++++++++++--
 .../reviews/final-review-2026-03-20.md        | 72 ----------------
 .../shared/backlog-init-command/state.md      | 20 ++---
 4 files changed, 160 insertions(+), 94 deletions(-)
 delete mode 100644 .oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
index 935c1e103..0519d6ae7 100644
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -1,9 +1,9 @@
 ---
-oat_status: complete
+oat_status: in_progress
 oat_ready_for: null
 oat_blockers: []
 oat_last_updated: 2026-03-20
-oat_current_task_id: null
+oat_current_task_id: p03-t01
 oat_generated: false
 ---
 
@@ -28,8 +28,9 @@ oat_generated: false
 | ------- | -------- | ----- | --------- |
 | Phase 1 | complete | 2     | 2/2       |
 | Phase 2 | complete | 1     | 1/1       |
+| Phase 3 | pending  | 2     | 0/2       |
 
-**Total:** 3/3 tasks completed
+**Total:** 3/5 tasks completed
 
 ---
 
@@ -150,6 +151,77 @@ oat_generated: false
 
 ---
 
+## Phase 3: Review Fixes (final)
+
+**Status:** pending
+**Started:** 2026-03-20
+
+### Task p03-t01: (review) Preserve empty backlog directories across git clone
+
+**Status:** pending
+
+**Files to change:**
+
+- `packages/cli/src/commands/backlog/init.ts`
+- `packages/cli/src/commands/backlog/init.test.ts`
+- `packages/cli/src/commands/backlog/regenerate-index.test.ts`
+
+**Notes:**
+
+- Seed tracked placeholders for empty scaffold directories so a committed/cloned backlog keeps the canonical shape.
+- Add a regression that proves `oat backlog regenerate-index` still works after the scaffold survives a git round-trip.
+
+---
+
+### Task p03-t02: (review) Add command-level coverage for `oat backlog init`
+
+**Status:** pending
+
+**Files to change:**
+
+- `packages/cli/src/commands/backlog/index.test.ts`
+- `packages/cli/src/commands/backlog/index.ts` (if testability hooks are needed)
+
+**Notes:**
+
+- Exercise the actual `backlog init` Commander action, not just the helper implementation.
+- Cover default root resolution, `--backlog-root`, text output, JSON output, and exit-code behavior.
+
+---
+
+## Review Received: final
+
+**Date:** 2026-03-20
+**Review artifact:** reviews/archived/final-review-2026-03-20.md
+
+**Findings:**
+
+- Critical: 1
+- Important: 1
+- Medium: 0
+- Minor: 0
+
+**Disposition:**
+
+- `C1` (empty scaffold directories are not persisted in git) → converted to `p03-t01`
+- `I1` (`oat backlog init` command wiring/output path is untested) → converted to `p03-t02`
+
+**Deferred Findings Disposition (Final Scope):**
+
+- Deferred Medium count: 0 (gate satisfied)
+- Minor findings count: 0 (gate satisfied)
+
+**New tasks added:** p03-t01, p03-t02
+
+**Next:** Execute fix tasks via the `oat-project-implement` skill.
+
+After the fix tasks are complete:
+
+- Update the final review row status to `fixes_completed`
+- Re-run `oat-project-review-provide code final`, then `oat-project-review-receive` to reach `passed`
+
+---
+
 ## Orchestration Runs
 
 > This section is used by `oat-project-subagent-implement` to log parallel execution runs.
diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
index c38622386..45705eb40 100644
--- a/.oat/projects/shared/backlog-init-command/plan.md
+++ b/.oat/projects/shared/backlog-init-command/plan.md
@@ -173,19 +173,84 @@ git commit -m "test(p02-t01): cover backlog init compatibility"
 
 ---
 
+## Phase 3: Review Fixes (final)
+
+Address the final review findings around git-persisted scaffold directories and command-level CLI coverage.
+
+### Task p03-t01: (review) Preserve empty backlog directories across git clone
+
+**Files:**
+
+- Modify: `packages/cli/src/commands/backlog/init.ts`
+- Modify: `packages/cli/src/commands/backlog/init.test.ts`
+- Modify: `packages/cli/src/commands/backlog/regenerate-index.test.ts`
+
+**Step 1: Understand the issue**
+
+Review finding: `oat backlog init` creates empty `items/` and `archived/` directories but does not seed tracked placeholders, so a committed/cloned scaffold can lose them and `oat backlog regenerate-index` then fails with `ENOENT`.
+Location: `packages/cli/src/commands/backlog/init.ts:69`
+
+**Step 2: Implement fix**
+
+Seed tracked placeholders such as `items/.gitkeep` and `archived/.gitkeep` when initializing a fresh scaffold, without disturbing existing directory contents. Add regression coverage that simulates the git round-trip and proves `regenerate-index` works without rerunning `init`.
+
+**Step 3: Verify**
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+Expected: All targeted backlog scaffold tests pass, including the clone-round-trip regression
+
+**Step 4: Commit**
+
+```bash
+git add packages/cli/src/commands/backlog/init.ts packages/cli/src/commands/backlog/init.test.ts packages/cli/src/commands/backlog/regenerate-index.test.ts
+git commit -m "fix(p03-t01): persist backlog scaffold directories in git"
+```
+
+---
+
+### Task p03-t02: (review) Add command-level coverage for `oat backlog init`
+
+**Files:**
+
+- Create: `packages/cli/src/commands/backlog/index.test.ts`
+- Modify: `packages/cli/src/commands/backlog/index.ts` (only if testability hooks are needed)
+
+**Step 1: Understand the issue**
+
+Review finding: current tests cover the initializer helper and help snapshots, but do not execute the actual Commander action for `oat backlog init`, leaving root resolution and text/JSON output behavior unverified.
+Location: `packages/cli/src/commands/backlog/index.ts:66`
+
+**Step 2: Implement fix**
+
+Add command-level tests that run `backlog init` through the command surface with injected dependencies and assert default backlog-root resolution, `--backlog-root` override behavior, text output, JSON output `{ status: 'ok', backlogRoot }`, and `process.exitCode`. Make only the minimal production changes needed to support that harness.
+
+**Step 3: Verify**
+
+Run: `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+Expected: Command-level and helper-level backlog tests all pass
+
+**Step 4: Commit**
+
+```bash
+git add packages/cli/src/commands/backlog/index.test.ts packages/cli/src/commands/backlog/index.ts packages/cli/src/commands/backlog/init.test.ts packages/cli/src/commands/backlog/regenerate-index.test.ts
+git commit -m "test(p03-t02): cover backlog init command surface"
+```
+
+---
+
 ## Reviews
 
 {Track reviews here after running the oat-project-review-provide and oat-project-review-receive skills.}
 
 {Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
 
-| Scope  | Type     | Status   | Date       | Artifact                           |
-| ------ | -------- | -------- | ---------- | ---------------------------------- |
-| p01    | code     | pending  | -          | -                                  |
-| p02    | code     | pending  | -          | -                                  |
-| final  | code     | received | 2026-03-20 | reviews/final-review-2026-03-20.md |
-| spec   | artifact | pending  | -          | -                                  |
-| design | artifact | pending  | -          | -                                  |
+| Scope  | Type     | Status      | Date       | Artifact                                    |
+| ------ | -------- | ----------- | ---------- | ------------------------------------------- |
+| p01    | code     | pending     | -          | -                                           |
+| p02    | code     | pending     | -          | -                                           |
+| final  | code     | fixes_added | 2026-03-20 | reviews/archived/final-review-2026-03-20.md |
+| spec   | artifact | pending     | -          | -                                           |
+| design | artifact | pending     | -          | -                                           |
 
 **Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
 
@@ -204,10 +269,11 @@ git commit -m "test(p02-t01): cover backlog init compatibility"
 
 - Phase 1: 2 tasks - add the scaffold initializer and wire `oat backlog init` into the backlog CLI
 - Phase 2: 1 task - add compatibility and idempotence regression coverage
+- Phase 3: 2 tasks - address final review findings around git persistence and command-level coverage
 
-**Total: 3 tasks**
+**Total: 5 tasks**
 
-Ready for code review and merge.
+Ready for review-fix implementation.
 
 ---
 
diff --git a/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md b/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md
deleted file mode 100644
index cb238bbe7..000000000
--- a/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20.md
+++ /dev/null
@@ -1,72 +0,0 @@
----
-oat_generated: true
-oat_generated_at: 2026-03-20
-oat_review_scope: final
-oat_review_type: code
-oat_project: /Users/thomas.stang/Code/open-agent-toolkit/.oat/projects/shared/backlog-init-command
----
-
-# Code Review: final
-
-**Reviewed:** 2026-03-20
-**Scope:** Final code review for `a9e5cd84f298baf8bb61214bc4ba85db03250d19..HEAD` in quick mode (`p01-t01`, `p01-t02`, `p02-t01`)
-**Files reviewed:** 9
-**Commits:** `a9e5cd84f298baf8bb61214bc4ba85db03250d19..HEAD` (8 commits in scope)
-
-## Summary
-
-I reviewed the quick-mode artifacts (`discovery.md`, `plan.md`, `implementation.md`, `state.md`) and the scoped CLI/test changes. The feature is mostly aligned with the discovery and plan, but the scaffold currently omits tracked placeholders for the empty `items/` and `archived/` directories, which means a freshly initialized backlog does not survive a commit/clone round-trip and `oat backlog regenerate-index` then fails with `ENOENT`. I also found a command-level verification gap: the helper is tested, but the actual `oat backlog init` action path and its text/JSON output contract are not covered by automated tests.
-
-## Findings
-
-### Critical
-
-- **Empty backlog directories are not persisted in git, breaking cloned scaffolds** (`packages/cli/src/commands/backlog/init.ts:69`)
-  - Issue: `initializeBacklog()` creates `items/` and `archived/` as empty directories but does not seed tracked placeholders such as `.gitkeep`. In practice, `oat backlog init` only leaves `index.md` and `completed.md` as tracked files; after committing and cloning that repo, the empty directories disappear and `oat backlog regenerate-index` fails with `ENOENT` because `.oat/repo/reference/backlog/items` is gone. That violates the quick-mode goal of creating the canonical local backlog scaffold and the success criterion that freshly scaffolded backlogs work with existing backlog commands.
-  - Fix: Create `items/.gitkeep` and `archived/.gitkeep` when seeding a fresh scaffold, without overwriting existing directory contents. Add a regression test that proves a committed/cloned initialized backlog still has the canonical directory shape and that `oat backlog regenerate-index` succeeds without rerunning `oat backlog init`.
-  - Requirement: Discovery success criteria "creates `.oat/repo/reference/backlog/`, `items/`, `archived/`, `index.md`, and `completed.md`" and "Freshly scaffolded backlog roots work with existing backlog commands such as `oat backlog regenerate-index`"
-
-### Important
-
-- **`oat backlog init` command wiring and output contract are untested** (`packages/cli/src/commands/backlog/index.ts:66`)
-  - Issue: The scoped tests exercise `initializeBacklog()` directly and cover help snapshots, but nothing executes the actual Commander action added in `createBacklogCommand()`. That leaves default root resolution, `--backlog-root`, exit-code behavior, and the plan-required text/JSON output contract unverified. This repo already uses command-level harness tests for comparable CLI surfaces, so the omission is notable.
-  - Fix: Add a command-level test file for the backlog command group that runs `backlog init` through Commander with injected dependencies and asserts default root resolution, `--backlog-root` override behavior, text output, JSON payload `{ status: 'ok', backlogRoot }`, and `process.exitCode`.
-
-### Minor
-
-None
-
-## Requirements/Design Alignment
-
-**Evidence sources used:** `discovery.md`, `plan.md`, `implementation.md`, `state.md`, `packages/cli/src/commands/backlog/index.ts`, `packages/cli/src/commands/backlog/init.ts`, `packages/cli/src/commands/backlog/init.test.ts`, `packages/cli/src/commands/backlog/regenerate-index.test.ts`, `packages/cli/src/commands/help-snapshots.test.ts`
-
-**Design alignment:** Not applicable (`design.md` is not present for quick mode).
-
-### Requirements Coverage
-
-| Requirement                                                                                         | Status      | Notes                                                                                                                                                           |
-| --------------------------------------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Add an explicit `oat backlog init` subcommand under the backlog CLI group                           | implemented | Registered in `createBacklogCommand()` and exposed in help snapshots.                                                                                           |
-| Create the canonical backlog scaffold when missing                                                  | partial     | Root, `items/`, `archived/`, `index.md`, and `completed.md` are created, but the empty directories are not trackable in git because no placeholders are seeded. |
-| Seed starter files with the managed index markers and expected starter sections                     | implemented | `index.md` and `completed.md` starter content matches the current backlog headings and marker contract.                                                         |
-| Re-running the scaffold must be idempotent and preserve curated content                             | implemented | `writeFileIfMissing()` keeps existing file contents intact; helper tests cover rerun preservation.                                                              |
-| Freshly scaffolded backlogs must work with existing commands such as `oat backlog regenerate-index` | partial     | Works in a temp directory before commit, but a committed/cloned empty backlog loses `items/` and then `regenerate-index` fails until `init` is rerun.           |
-| `oat backlog init` should report the backlog root in text and JSON modes                            | implemented | The action logs both formats, but there is no command-level regression coverage for this contract yet.                                                          |
-
-### Extra Work (not in declared requirements)
-
-None
-
-## Verification Commands
-
-Run these to verify the implementation:
-
-```bash
-pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts
-pnpm type-check
-tmp=$(mktemp -d) && repo="$tmp/repo" && clone="$tmp/clone" && git init -q "$repo" && (cd "$repo" && git config user.email review@example.com && git config user.name reviewer) && pnpm run cli -- --cwd "$repo" backlog init && (cd "$repo" && git add . && git commit -qm init) && git clone -q "$repo" "$clone" && pnpm run cli -- --cwd "$clone" backlog regenerate-index
-```
-
-## Recommended Next Step
-
-Run the `oat-project-review-receive` skill to convert findings into plan tasks.
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index 79cc90b55..facf0ccf8 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -1,6 +1,6 @@
 ---
-oat_current_task: null
-oat_last_commit: cee41cca
+oat_current_task: p03-t01
+oat_last_commit: 359423a8
 oat_blockers: []
 associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
 oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
@@ -14,34 +14,34 @@ oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-20T22:05:00Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-20T23:19:14Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
 # Project State: backlog-init-command
 
-**Status:** Awaiting Final Review
+**Status:** Review Fixes Queued
 **Started:** 2026-03-20
 **Last Updated:** 2026-03-20
 
 ## Current Phase
 
-Implementation - Tasks complete; awaiting final review.
+Implementation - Review-fix tasks queued at `p03-t01`.
 
 ## Artifacts
 
 - **Discovery:** `discovery.md` (complete)
 - **Spec:** N/A (quick mode)
 - **Design:** N/A (quick mode)
-- **Plan:** `plan.md` (complete — 3 tasks across 2 phases)
-- **Implementation:** `implementation.md` (complete — all planned tasks finished)
+- **Plan:** `plan.md` (complete — 5 tasks across 3 phases, including review fixes)
+- **Implementation:** `implementation.md` (in progress — fix tasks queued from final review)
 
 ## Progress
 
 - ✓ Discovery complete
 - ✓ Plan complete
-- ✓ Implementation tasks complete
-- ⧗ Awaiting final review
+- ✓ Initial implementation tasks complete
+- ⧗ Review fixes queued (`p03-t01`, `p03-t02`)
 
 ## Blockers
 
@@ -49,4 +49,4 @@ None
 
 ## Next Milestone
 
-Run final review for the completed implementation.
+Run `oat-project-implement` to execute review-fix tasks starting at `p03-t01`.

From 5748eddb9b82e4c71307606d12b487810636a166 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 18:29:41 -0500
Subject: [PATCH 11/21] fix(p03-t01): persist backlog scaffold directories in
 git

---
 .../cli/src/commands/backlog/init.test.ts     | 20 +++++++++
 packages/cli/src/commands/backlog/init.ts     |  9 ++++
 .../commands/backlog/regenerate-index.test.ts | 41 +++++++++++++++++++
 3 files changed, 70 insertions(+)

diff --git a/packages/cli/src/commands/backlog/init.test.ts b/packages/cli/src/commands/backlog/init.test.ts
index 8ff72272c..5787c7ea2 100644
--- a/packages/cli/src/commands/backlog/init.test.ts
+++ b/packages/cli/src/commands/backlog/init.test.ts
@@ -26,6 +26,12 @@ describe('initializeBacklog', () => {
     await expect(
       access(join(backlogRoot, 'archived')),
     ).resolves.toBeUndefined();
+    await expect(
+      access(join(backlogRoot, 'items', '.gitkeep')),
+    ).resolves.toBeUndefined();
+    await expect(
+      access(join(backlogRoot, 'archived', '.gitkeep')),
+    ).resolves.toBeUndefined();
 
     const index = await readFile(join(backlogRoot, 'index.md'), 'utf8');
     expect(index).toContain('# OAT Backlog Index');
@@ -82,4 +88,18 @@ describe('initializeBacklog', () => {
       '- Keep this curated summary.',
     );
   });
+
+  it('does not overwrite existing directory placeholders on rerun', async () => {
+    const backlogRoot = await mkdtemp(join(tmpdir(), 'oat-backlog-init-'));
+    tempDirs.push(backlogRoot);
+
+    await initializeBacklog(backlogRoot);
+
+    const itemsPlaceholder = join(backlogRoot, 'items', '.gitkeep');
+    await writeFile(itemsPlaceholder, 'keep me\n', 'utf8');
+
+    await initializeBacklog(backlogRoot);
+
+    await expect(readFile(itemsPlaceholder, 'utf8')).resolves.toBe('keep me\n');
+  });
 });
diff --git a/packages/cli/src/commands/backlog/init.ts b/packages/cli/src/commands/backlog/init.ts
index 2ef95a1a3..76bfc72c9 100644
--- a/packages/cli/src/commands/backlog/init.ts
+++ b/packages/cli/src/commands/backlog/init.ts
@@ -3,6 +3,7 @@ import { join } from 'node:path';
 
 const INDEX_START = '<!-- OAT BACKLOG-INDEX -->';
 const INDEX_END = '<!-- END OAT BACKLOG-INDEX -->';
+const DIRECTORY_PLACEHOLDER = '.gitkeep';
 
 const EMPTY_MANAGED_TABLE = [
   INDEX_START,
@@ -69,6 +70,14 @@ async function writeFileIfMissing(
 export async function initializeBacklog(backlogRoot: string): Promise<void> {
   await mkdir(join(backlogRoot, 'items'), { recursive: true });
   await mkdir(join(backlogRoot, 'archived'), { recursive: true });
+  await writeFileIfMissing(
+    join(backlogRoot, 'items', DIRECTORY_PLACEHOLDER),
+    '',
+  );
+  await writeFileIfMissing(
+    join(backlogRoot, 'archived', DIRECTORY_PLACEHOLDER),
+    '',
+  );
 
   await writeFileIfMissing(join(backlogRoot, 'index.md'), STARTER_INDEX);
   await writeFileIfMissing(
diff --git a/packages/cli/src/commands/backlog/regenerate-index.test.ts b/packages/cli/src/commands/backlog/regenerate-index.test.ts
index fa5b2a505..edaf54785 100644
--- a/packages/cli/src/commands/backlog/regenerate-index.test.ts
+++ b/packages/cli/src/commands/backlog/regenerate-index.test.ts
@@ -1,3 +1,4 @@
+import { execFileSync } from 'node:child_process';
 import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -178,4 +179,44 @@ describe('regenerateBacklogIndex', () => {
       '| _No backlog items yet_ | - | - | - | - | - |',
     );
   });
+
+  it('works after a git commit and clone round-trip without rerunning init', async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), 'oat-backlog-git-'));
+    tempDirs.push(tempRoot);
+
+    const repoRoot = join(tempRoot, 'repo');
+    const cloneRoot = join(tempRoot, 'clone');
+    const backlogRoot = join(repoRoot, '.oat', 'repo', 'reference', 'backlog');
+
+    await mkdir(repoRoot, { recursive: true });
+    await initializeBacklog(backlogRoot);
+
+    execFileSync('git', ['init', '-q'], { cwd: repoRoot });
+    execFileSync('git', ['config', 'user.email', 'review@example.com'], {
+      cwd: repoRoot,
+    });
+    execFileSync('git', ['config', 'user.name', 'reviewer'], { cwd: repoRoot });
+    execFileSync('git', ['add', '.'], { cwd: repoRoot });
+    execFileSync('git', ['commit', '-qm', 'init backlog scaffold'], {
+      cwd: repoRoot,
+    });
+    execFileSync('git', ['clone', '-q', repoRoot, cloneRoot], {
+      cwd: tempRoot,
+    });
+
+    const clonedBacklogRoot = join(
+      cloneRoot,
+      '.oat',
+      'repo',
+      'reference',
+      'backlog',
+    );
+
+    await expect(
+      readFile(join(clonedBacklogRoot, 'items', '.gitkeep'), 'utf8'),
+    ).resolves.toBe('');
+    await expect(
+      regenerateBacklogIndex(clonedBacklogRoot),
+    ).resolves.toBeUndefined();
+  });
 });

From 00cc684838ef691a95e8eca4d197033e25aa967e Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 18:30:08 -0500
Subject: [PATCH 12/21] chore(oat): update tracking artifacts for p03-t01

---
 .../backlog-init-command/implementation.md    | 42 ++++++++++++-------
 .../shared/backlog-init-command/state.md      | 12 +++---
 2 files changed, 32 insertions(+), 22 deletions(-)

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
index 0519d6ae7..baed4f541 100644
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -3,7 +3,7 @@ oat_status: in_progress
 oat_ready_for: null
 oat_blockers: []
 oat_last_updated: 2026-03-20
-oat_current_task_id: p03-t01
+oat_current_task_id: p03-t02
 oat_generated: false
 ---
 
@@ -24,13 +24,13 @@ oat_generated: false
 
 ## Progress Overview
 
-| Phase   | Status   | Tasks | Completed |
-| ------- | -------- | ----- | --------- |
-| Phase 1 | complete | 2     | 2/2       |
-| Phase 2 | complete | 1     | 1/1       |
-| Phase 3 | pending  | 2     | 0/2       |
+| Phase   | Status      | Tasks | Completed |
+| ------- | ----------- | ----- | --------- |
+| Phase 1 | complete    | 2     | 2/2       |
+| Phase 2 | complete    | 1     | 1/1       |
+| Phase 3 | in_progress | 2     | 1/2       |
 
-**Total:** 3/5 tasks completed
+**Total:** 4/5 tasks completed
 
 ---
 
@@ -153,23 +153,33 @@ oat_generated: false
 
 ## Phase 3: Review Fixes (final)
 
-**Status:** pending
+**Status:** in_progress
 **Started:** 2026-03-20
 
 ### Task p03-t01: (review) Preserve empty backlog directories across git clone
 
-**Status:** pending
+**Status:** completed
+**Commit:** bf784cc7
 
-**Files to change:**
+**Outcome (required when completed):**
 
-- `packages/cli/src/commands/backlog/init.ts`
-- `packages/cli/src/commands/backlog/init.test.ts`
-- `packages/cli/src/commands/backlog/regenerate-index.test.ts`
+- Added `.gitkeep` placeholders to the scaffolded `items/` and `archived/` directories so the canonical backlog shape survives git commits and clones.
+- Added regression coverage that commits and clones a scaffolded repo before running `regenerate-index`, proving the backlog remains usable without rerunning `init`.
 
-**Notes:**
+**Files changed:**
+
+- `packages/cli/src/commands/backlog/init.ts` - seeds tracked placeholders for empty scaffold directories
+- `packages/cli/src/commands/backlog/init.test.ts` - verifies placeholder creation and rerun preservation
+- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - covers the git round-trip compatibility path
+
+**Verification:**
+
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+- Result: Pass; targeted scaffold and round-trip regressions succeeded
+
+**Notes / Decisions:**
 
-- Seed tracked placeholders for empty scaffold directories so a committed/cloned backlog keeps the canonical shape.
-- Add a regression that proves `oat backlog regenerate-index` still works after the scaffold survives a git round-trip.
+- Used `.gitkeep` so empty directories remain versionable without changing runtime behavior; `regenerate-index` already ignores non-Markdown files.
 
 ---
 
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index facf0ccf8..9a26e24b9 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -1,6 +1,6 @@
 ---
-oat_current_task: p03-t01
-oat_last_commit: 359423a8
+oat_current_task: p03-t02
+oat_last_commit: bf784cc7
 oat_blockers: []
 associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
 oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
@@ -14,7 +14,7 @@ oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-20T23:19:14Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-20T23:29:47Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
@@ -26,7 +26,7 @@ oat_generated: false
 
 ## Current Phase
 
-Implementation - Review-fix tasks queued at `p03-t01`.
+Implementation - Review fixes in progress at `p03-t02`.
 
 ## Artifacts
 
@@ -41,7 +41,7 @@ Implementation - Review-fix tasks queued at `p03-t01`.
 - ✓ Discovery complete
 - ✓ Plan complete
 - ✓ Initial implementation tasks complete
-- ⧗ Review fixes queued (`p03-t01`, `p03-t02`)
+- ⧗ Review fixes in progress (`p03-t02` remaining)
 
 ## Blockers
 
@@ -49,4 +49,4 @@ None
 
 ## Next Milestone
 
-Run `oat-project-implement` to execute review-fix tasks starting at `p03-t01`.
+Continue `oat-project-implement` from `p03-t02`.

From 97e05b687ef6606c7c98c9eb347d7f6616c38daf Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 18:30:23 -0500
Subject: [PATCH 13/21] test(p03-t02): cover backlog init command surface

---
 .../cli/src/commands/backlog/index.test.ts    | 127 ++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 packages/cli/src/commands/backlog/index.test.ts

diff --git a/packages/cli/src/commands/backlog/index.test.ts b/packages/cli/src/commands/backlog/index.test.ts
new file mode 100644
index 000000000..0d5e52cea
--- /dev/null
+++ b/packages/cli/src/commands/backlog/index.test.ts
@@ -0,0 +1,127 @@
+import type { CommandContext, GlobalOptions } from '@app/command-context';
+import {
+  createLoggerCapture,
+  type LoggerCapture,
+} from '@commands/__tests__/helpers';
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createBacklogCommand } from './index';
+
+function createHarness(): {
+  capture: LoggerCapture;
+  command: Command;
+  initializeBacklog: ReturnType<typeof vi.fn>;
+  resolveProjectRoot: ReturnType<typeof vi.fn>;
+} {
+  const capture = createLoggerCapture();
+  const initializeBacklog = vi.fn(async (_backlogRoot: string) => {});
+  const resolveProjectRoot = vi.fn(
+    async (_cwd: string) => '/tmp/workspace/repo',
+  );
+
+  const command = createBacklogCommand({
+    buildCommandContext: (globalOptions: GlobalOptions): CommandContext => ({
+      scope: (globalOptions.scope ?? 'all') as CommandContext['scope'],
+      dryRun: false,
+      verbose: globalOptions.verbose ?? false,
+      json: globalOptions.json ?? false,
+      cwd: globalOptions.cwd ?? '/tmp/workspace',
+      home: '/tmp/home',
+      interactive: !(globalOptions.json ?? false),
+      logger: capture.logger,
+    }),
+    initializeBacklog,
+    resolveProjectRoot,
+  });
+
+  return {
+    capture,
+    command,
+    initializeBacklog,
+    resolveProjectRoot,
+  };
+}
+
+async function runCommand(
+  command: Command,
+  globalArgs: string[] = [],
+  cmdArgs: string[] = [],
+): Promise<void> {
+  const program = new Command()
+    .name('oat')
+    .option('--json')
+    .option('--verbose')
+    .option('--cwd <path>')
+    .exitOverride();
+
+  program.addCommand(command);
+
+  await program.parseAsync([...globalArgs, 'backlog', 'init', ...cmdArgs], {
+    from: 'user',
+  });
+}
+
+describe('createBacklogCommand', () => {
+  let originalExitCode: number | undefined;
+
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+  });
+
+  afterEach(() => {
+    process.exitCode = originalExitCode;
+  });
+
+  it('initializes the default backlog root resolved from the project root', async () => {
+    const { command, capture, initializeBacklog, resolveProjectRoot } =
+      createHarness();
+
+    await runCommand(command);
+
+    expect(resolveProjectRoot).toHaveBeenCalledWith('/tmp/workspace');
+    expect(initializeBacklog).toHaveBeenCalledWith(
+      '/tmp/workspace/repo/.oat/repo/reference/backlog',
+    );
+    expect(capture.info).toContain(
+      'Initialized backlog scaffold at /tmp/workspace/repo/.oat/repo/reference/backlog',
+    );
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('uses the configured backlog root override relative to cwd', async () => {
+    const { command, capture, initializeBacklog, resolveProjectRoot } =
+      createHarness();
+
+    await runCommand(
+      command,
+      ['--cwd', '/tmp/override-workspace'],
+      ['--backlog-root', 'custom/backlog'],
+    );
+
+    expect(resolveProjectRoot).not.toHaveBeenCalled();
+    expect(initializeBacklog).toHaveBeenCalledWith(
+      '/tmp/override-workspace/custom/backlog',
+    );
+    expect(capture.info).toContain(
+      'Initialized backlog scaffold at /tmp/override-workspace/custom/backlog',
+    );
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('outputs structured JSON for backlog init', async () => {
+    const { command, capture, initializeBacklog } = createHarness();
+
+    await runCommand(command, ['--json']);
+
+    expect(initializeBacklog).toHaveBeenCalledWith(
+      '/tmp/workspace/repo/.oat/repo/reference/backlog',
+    );
+    expect(capture.jsonPayloads[0]).toEqual({
+      status: 'ok',
+      backlogRoot: '/tmp/workspace/repo/.oat/repo/reference/backlog',
+    });
+    expect(process.exitCode).toBe(0);
+  });
+});

From 9b354cf26bfaad49567243aebdf150221929a83d Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 18:31:39 -0500
Subject: [PATCH 14/21] chore(oat): update tracking artifacts for p03-t02

---
 .../backlog-init-command/implementation.md    | 80 ++++++++++++++-----
 .../shared/backlog-init-command/plan.md       | 16 ++--
 .../shared/backlog-init-command/state.md      | 17 ++--
 3 files changed, 77 insertions(+), 36 deletions(-)

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
index baed4f541..49d889c61 100644
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -1,9 +1,9 @@
 ---
-oat_status: in_progress
+oat_status: complete
 oat_ready_for: null
 oat_blockers: []
 oat_last_updated: 2026-03-20
-oat_current_task_id: p03-t02
+oat_current_task_id: null
 oat_generated: false
 ---
 
@@ -24,13 +24,13 @@ oat_generated: false
 
 ## Progress Overview
 
-| Phase   | Status      | Tasks | Completed |
-| ------- | ----------- | ----- | --------- |
-| Phase 1 | complete    | 2     | 2/2       |
-| Phase 2 | complete    | 1     | 1/1       |
-| Phase 3 | in_progress | 2     | 1/2       |
+| Phase   | Status   | Tasks | Completed |
+| ------- | -------- | ----- | --------- |
+| Phase 1 | complete | 2     | 2/2       |
+| Phase 2 | complete | 1     | 1/1       |
+| Phase 3 | complete | 2     | 2/2       |
 
-**Total:** 4/5 tasks completed
+**Total:** 5/5 tasks completed
 
 ---
 
@@ -153,9 +153,35 @@ oat_generated: false
 
 ## Phase 3: Review Fixes (final)
 
-**Status:** in_progress
+**Status:** complete
 **Started:** 2026-03-20
 
+### Phase Summary (fill when phase is complete)
+
+**Outcome (what changed):**
+
+- Persisted the scaffolded backlog directory shape across git commit/clone round-trips by seeding `.gitkeep` placeholders.
+- Added command-level coverage for the actual `oat backlog init` action path, including default root resolution, `--backlog-root`, text output, JSON output, and exit-code behavior.
+- Closed both final-review findings without widening the feature scope beyond backlog scaffolding and verification.
+
+**Key files touched:**
+
+- `packages/cli/src/commands/backlog/init.ts` - seeds tracked placeholders for empty scaffold directories
+- `packages/cli/src/commands/backlog/init.test.ts` - verifies placeholder creation and rerun preservation
+- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - covers git round-trip compatibility
+- `packages/cli/src/commands/backlog/index.test.ts` - exercises the `backlog init` command surface
+
+**Verification:**
+
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+- Run: `pnpm test && pnpm lint && pnpm type-check && pnpm build`
+- Result: Pass; targeted backlog coverage and repo-wide verification all succeeded
+
+**Notes / Decisions:**
+
+- The command surface was already testable with dependency injection, so `p03-t02` required no production code changes.
+
 ### Task p03-t01: (review) Preserve empty backlog directories across git clone
 
 **Status:** completed
@@ -185,17 +211,26 @@ oat_generated: false
 
 ### Task p03-t02: (review) Add command-level coverage for `oat backlog init`
 
-**Status:** pending
+**Status:** completed
+**Commit:** 009f0619
 
-**Files to change:**
+**Outcome (required when completed):**
 
-- `packages/cli/src/commands/backlog/index.test.ts`
-- `packages/cli/src/commands/backlog/index.ts` (if testability hooks are needed)
+- Added a dedicated command harness for `oat backlog init` that exercises the Commander action instead of only the helper.
+- Verified default backlog-root resolution, `--backlog-root` override behavior, text output, JSON payload shape, and `process.exitCode`.
 
-**Notes:**
+**Files changed:**
+
+- `packages/cli/src/commands/backlog/index.test.ts` - covers the `backlog init` command surface and output contract
+
+**Verification:**
+
+- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+- Result: Pass; command-level and helper-level backlog tests all succeeded
+
+**Notes / Decisions:**
 
-- Exercise the actual `backlog init` Commander action, not just the helper implementation.
-- Cover default root resolution, `--backlog-root`, text output, JSON output, and exit-code behavior.
+- Kept the production implementation unchanged because the existing dependency seams were sufficient for command-level testing.
 
 ---
 
@@ -223,11 +258,11 @@ oat_generated: false
 
 **New tasks added:** p03-t01, p03-t02
 
-**Next:** Execute fix tasks via the `oat-project-implement` skill.
+**Next:** Request final re-review via `oat-project-review-provide code final`.
 
 After the fix tasks are complete:
 
-- Update the final review row status to `fixes_completed`
+- The final review row is `fixes_completed`
 - Re-run `oat-project-review-provide code final`, then `oat-project-review-receive` to reach `passed`
 
 ---
@@ -382,18 +417,21 @@ Track test execution during implementation.
 **What shipped:**
 
 - Added an explicit `oat backlog init` command for scaffolding the canonical local backlog directory structure.
-- Added a reusable initializer that creates `items/`, `archived/`, `index.md`, and `completed.md` without overwriting existing backlog files on rerun.
-- Added regression coverage proving the scaffolded backlog shape is compatible with `oat backlog regenerate-index` and preserves curated overview edits.
+- Added a reusable initializer that creates `items/`, `archived/`, `index.md`, and `completed.md` without overwriting existing backlog files on rerun, and now seeds `.gitkeep` placeholders so the scaffold survives git round-trips.
+- Added regression coverage proving the scaffolded backlog shape is compatible with `oat backlog regenerate-index`, preserves curated overview edits, and remains valid after commit/clone.
+- Added command-level coverage for the `oat backlog init` action path and its text/JSON output contract.
 
 **Behavioral changes (user-facing):**
 
 - Users can now run `oat backlog init` in a fresh repo to create the starter backlog structure before using other file-backed backlog flows.
 - Re-running the command leaves curated backlog content intact instead of resetting the backlog index or completed summary files.
+- Repositories that commit a freshly initialized backlog now retain the empty `items/` and `archived/` directories after clone.
 
 **Key files / modules:**
 
 - `packages/cli/src/commands/backlog/init.ts` - backlog scaffold helper and starter file content
 - `packages/cli/src/commands/backlog/index.ts` - `oat backlog init` command wiring
+- `packages/cli/src/commands/backlog/index.test.ts` - command-level `backlog init` coverage
 - `packages/cli/src/commands/backlog/init.test.ts` - scaffold creation and idempotence coverage
 - `packages/cli/src/commands/backlog/regenerate-index.test.ts` - scaffold compatibility coverage
 
@@ -402,6 +440,8 @@ Track test execution during implementation.
 - `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
 - `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
 - `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
+- `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
+- `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
 - `pnpm test`
 - `pnpm lint`
 - `pnpm type-check`
diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
index 45705eb40..a0d2b462d 100644
--- a/.oat/projects/shared/backlog-init-command/plan.md
+++ b/.oat/projects/shared/backlog-init-command/plan.md
@@ -244,13 +244,13 @@ git commit -m "test(p03-t02): cover backlog init command surface"
 
 {Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
 
-| Scope  | Type     | Status      | Date       | Artifact                                    |
-| ------ | -------- | ----------- | ---------- | ------------------------------------------- |
-| p01    | code     | pending     | -          | -                                           |
-| p02    | code     | pending     | -          | -                                           |
-| final  | code     | fixes_added | 2026-03-20 | reviews/archived/final-review-2026-03-20.md |
-| spec   | artifact | pending     | -          | -                                           |
-| design | artifact | pending     | -          | -                                           |
+| Scope  | Type     | Status          | Date       | Artifact                                    |
+| ------ | -------- | --------------- | ---------- | ------------------------------------------- |
+| p01    | code     | pending         | -          | -                                           |
+| p02    | code     | pending         | -          | -                                           |
+| final  | code     | fixes_completed | 2026-03-20 | reviews/archived/final-review-2026-03-20.md |
+| spec   | artifact | pending         | -          | -                                           |
+| design | artifact | pending         | -          | -                                           |
 
 **Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
 
@@ -273,7 +273,7 @@ git commit -m "test(p03-t02): cover backlog init command surface"
 
 **Total: 5 tasks**
 
-Ready for review-fix implementation.
+Ready for final re-review.
 
 ---
 
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index 9a26e24b9..0a5e24bb0 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -1,6 +1,6 @@
 ---
-oat_current_task: p03-t02
-oat_last_commit: bf784cc7
+oat_current_task: null
+oat_last_commit: 009f0619
 oat_blockers: []
 associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
 oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
@@ -14,19 +14,19 @@ oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-20T23:29:47Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-20T23:31:02Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
 # Project State: backlog-init-command
 
-**Status:** Review Fixes Queued
+**Status:** Awaiting Final Re-Review
 **Started:** 2026-03-20
 **Last Updated:** 2026-03-20
 
 ## Current Phase
 
-Implementation - Review fixes in progress at `p03-t02`.
+Implementation - Review-fix tasks complete; awaiting final re-review.
 
 ## Artifacts
 
@@ -34,14 +34,15 @@ Implementation - Review fixes in progress at `p03-t02`.
 - **Spec:** N/A (quick mode)
 - **Design:** N/A (quick mode)
 - **Plan:** `plan.md` (complete — 5 tasks across 3 phases, including review fixes)
-- **Implementation:** `implementation.md` (in progress — fix tasks queued from final review)
+- **Implementation:** `implementation.md` (complete — all planned and review-fix tasks finished)
 
 ## Progress
 
 - ✓ Discovery complete
 - ✓ Plan complete
 - ✓ Initial implementation tasks complete
-- ⧗ Review fixes in progress (`p03-t02` remaining)
+- ✓ Review fixes complete
+- ⧗ Awaiting final re-review
 
 ## Blockers
 
@@ -49,4 +50,4 @@ None
 
 ## Next Milestone
 
-Continue `oat-project-implement` from `p03-t02`.
+Run `oat-project-review-provide code final` for the final re-review.

From d6ed3344d138e7abba1821c0b62329456b9dd133 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:01:26 -0500
Subject: [PATCH 15/21] chore(oat): record final review artifact

---
 .../shared/backlog-init-command/plan.md       | 14 ++---
 .../reviews/final-review-2026-03-20-v2.md     | 63 +++++++++++++++++++
 2 files changed, 70 insertions(+), 7 deletions(-)
 create mode 100644 .oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md

diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
index a0d2b462d..a81734309 100644
--- a/.oat/projects/shared/backlog-init-command/plan.md
+++ b/.oat/projects/shared/backlog-init-command/plan.md
@@ -244,13 +244,13 @@ git commit -m "test(p03-t02): cover backlog init command surface"
 
 {Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
 
-| Scope  | Type     | Status          | Date       | Artifact                                    |
-| ------ | -------- | --------------- | ---------- | ------------------------------------------- |
-| p01    | code     | pending         | -          | -                                           |
-| p02    | code     | pending         | -          | -                                           |
-| final  | code     | fixes_completed | 2026-03-20 | reviews/archived/final-review-2026-03-20.md |
-| spec   | artifact | pending         | -          | -                                           |
-| design | artifact | pending         | -          | -                                           |
+| Scope  | Type     | Status   | Date       | Artifact                              |
+| ------ | -------- | -------- | ---------- | ------------------------------------- |
+| p01    | code     | pending  | -          | -                                     |
+| p02    | code     | pending  | -          | -                                     |
+| final  | code     | received | 2026-03-20 | reviews/final-review-2026-03-20-v2.md |
+| spec   | artifact | pending  | -          | -                                     |
+| design | artifact | pending  | -          | -                                     |
 
 **Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
 
diff --git a/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md b/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md
new file mode 100644
index 000000000..14b1e7b92
--- /dev/null
+++ b/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md
@@ -0,0 +1,63 @@
+---
+oat_generated: true
+oat_generated_at: 2026-03-20
+oat_review_scope: final
+oat_review_type: code
+oat_project: /Users/thomas.stang/Code/open-agent-toolkit/.oat/projects/shared/backlog-init-command
+---
+
+# Code Review: final
+
+**Reviewed:** 2026-03-20
+**Scope:** Final narrow re-review of review-fix tasks `p03-t01` and `p03-t02` over commits `bf784cc7` and `009f0619`
+**Files reviewed:** 4
+**Commits:** `bf784cc7`, `009f0619`
+
+## Summary
+
+I reviewed the quick-mode artifacts used for requirements context (`discovery.md`, `plan.md`, `implementation.md`, `state.md`), the archived prior final review, and the four scoped code/test files from the two review-fix commits. Both prior findings are closed: the scaffold now persists empty backlog directories across git commit/clone round-trips, and the `oat backlog init` Commander action path now has direct command-level coverage for root resolution, output modes, and exit-code behavior. Targeted verification passed with no new scoped regressions found.
+
+## Findings
+
+### Critical
+
+None
+
+### Important
+
+None
+
+### Minor
+
+None
+
+## Requirements/Design Alignment
+
+**Evidence sources used:** `discovery.md`, `plan.md`, `implementation.md`, `state.md`, `reviews/archived/final-review-2026-03-20.md`, `packages/cli/src/commands/backlog/init.ts`, `packages/cli/src/commands/backlog/init.test.ts`, `packages/cli/src/commands/backlog/regenerate-index.test.ts`, `packages/cli/src/commands/backlog/index.test.ts`, `packages/cli/src/commands/backlog/index.ts`
+
+**Design alignment:** Not applicable (`design.md` is not present for quick mode).
+
+### Requirements Coverage
+
+| Requirement                                                                                                                        | Status      | Notes                                                                                                                                                                                                                                                                                                                                  |
+| ---------------------------------------------------------------------------------------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Persist the scaffolded `items/` and `archived/` directories across git commit/clone round-trips                                    | implemented | `initializeBacklog()` now seeds `items/.gitkeep` and `archived/.gitkeep` without overwriting existing placeholders (`packages/cli/src/commands/backlog/init.ts:70`). `init.test.ts` covers creation and rerun preservation (`packages/cli/src/commands/backlog/init.test.ts:19`, `packages/cli/src/commands/backlog/init.test.ts:92`). |
+| Freshly scaffolded backlog roots remain usable with `oat backlog regenerate-index` after clone, without rerunning `init`           | implemented | The new git round-trip regression commits and clones a scaffolded repo, then runs `regenerateBacklogIndex()` successfully against the clone (`packages/cli/src/commands/backlog/regenerate-index.test.ts:183`).                                                                                                                        |
+| Add command-level coverage for the `oat backlog init` action path                                                                  | implemented | `index.test.ts` now runs the Commander action through `createBacklogCommand()` rather than only testing the helper (`packages/cli/src/commands/backlog/index.test.ts:77`).                                                                                                                                                             |
+| Verify default root resolution, `--backlog-root` override, text output, JSON output, and `process.exitCode` for `oat backlog init` | implemented | The command harness asserts default project-root resolution, override behavior, text output, JSON payload shape, and zero exit code (`packages/cli/src/commands/backlog/index.test.ts:77`, `packages/cli/src/commands/backlog/index.test.ts:93`, `packages/cli/src/commands/backlog/index.test.ts:113`).                               |
+
+### Extra Work (not in declared requirements)
+
+None
+
+## Verification Commands
+
+Run these to verify the implementation:
+
+```bash
+pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts
+```
+
+## Recommended Next Step
+
+Run the `oat-project-review-receive` skill to convert findings into plan tasks.

From f422b2c2ed89958b9afa018113529d4e8e4cb085 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:07:38 -0500
Subject: [PATCH 16/21] chore(oat): record passing final review for
 backlog-init-command

---
 .../backlog-init-command/implementation.md    | 23 +++++++
 .../shared/backlog-init-command/plan.md       | 16 ++---
 .../reviews/final-review-2026-03-20-v2.md     | 63 -------------------
 .../shared/backlog-init-command/state.md      | 12 ++--
 4 files changed, 37 insertions(+), 77 deletions(-)
 delete mode 100644 .oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md

diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
index 49d889c61..54de22410 100644
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ b/.oat/projects/shared/backlog-init-command/implementation.md
@@ -267,6 +267,29 @@ After the fix tasks are complete:
 
 ---
 
+## Review Received: final (v2 re-review — PASSED)
+
+**Date:** 2026-03-20
+**Review artifact:** reviews/archived/final-review-2026-03-20-v2.md
+
+**Findings:**
+
+- Critical: 0
+- Important: 0
+- Medium: 0
+- Minor: 0
+
+**Result:** PASSED — no new findings. The prior final-review issues are resolved by `p03-t01` and `p03-t02`.
+
+**Final-scope gates:**
+
+- Deferred Medium gate: satisfied (0 deferred mediums)
+- Minor findings gate: satisfied (0 minor findings in the passing re-review)
+
+**Next:** Create the final PR via `oat-project-pr-final`.
+
+---
+
 ## Orchestration Runs
 
 > This section is used by `oat-project-subagent-implement` to log parallel execution runs.
diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
index a81734309..ed15461bd 100644
--- a/.oat/projects/shared/backlog-init-command/plan.md
+++ b/.oat/projects/shared/backlog-init-command/plan.md
@@ -244,13 +244,13 @@ git commit -m "test(p03-t02): cover backlog init command surface"
 
 {Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
 
-| Scope  | Type     | Status   | Date       | Artifact                              |
-| ------ | -------- | -------- | ---------- | ------------------------------------- |
-| p01    | code     | pending  | -          | -                                     |
-| p02    | code     | pending  | -          | -                                     |
-| final  | code     | received | 2026-03-20 | reviews/final-review-2026-03-20-v2.md |
-| spec   | artifact | pending  | -          | -                                     |
-| design | artifact | pending  | -          | -                                     |
+| Scope  | Type     | Status  | Date       | Artifact                                       |
+| ------ | -------- | ------- | ---------- | ---------------------------------------------- |
+| p01    | code     | pending | -          | -                                              |
+| p02    | code     | pending | -          | -                                              |
+| final  | code     | passed  | 2026-03-20 | reviews/archived/final-review-2026-03-20-v2.md |
+| spec   | artifact | pending | -          | -                                              |
+| design | artifact | pending | -          | -                                              |
 
 **Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
 
@@ -273,7 +273,7 @@ git commit -m "test(p03-t02): cover backlog init command surface"
 
 **Total: 5 tasks**
 
-Ready for final re-review.
+Ready for PR and finalization.
 
 ---
 
diff --git a/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md b/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md
deleted file mode 100644
index 14b1e7b92..000000000
--- a/.oat/projects/shared/backlog-init-command/reviews/final-review-2026-03-20-v2.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-oat_generated: true
-oat_generated_at: 2026-03-20
-oat_review_scope: final
-oat_review_type: code
-oat_project: /Users/thomas.stang/Code/open-agent-toolkit/.oat/projects/shared/backlog-init-command
----
-
-# Code Review: final
-
-**Reviewed:** 2026-03-20
-**Scope:** Final narrow re-review of review-fix tasks `p03-t01` and `p03-t02` over commits `bf784cc7` and `009f0619`
-**Files reviewed:** 4
-**Commits:** `bf784cc7`, `009f0619`
-
-## Summary
-
-I reviewed the quick-mode artifacts used for requirements context (`discovery.md`, `plan.md`, `implementation.md`, `state.md`), the archived prior final review, and the four scoped code/test files from the two review-fix commits. Both prior findings are closed: the scaffold now persists empty backlog directories across git commit/clone round-trips, and the `oat backlog init` Commander action path now has direct command-level coverage for root resolution, output modes, and exit-code behavior. Targeted verification passed with no new scoped regressions found.
-
-## Findings
-
-### Critical
-
-None
-
-### Important
-
-None
-
-### Minor
-
-None
-
-## Requirements/Design Alignment
-
-**Evidence sources used:** `discovery.md`, `plan.md`, `implementation.md`, `state.md`, `reviews/archived/final-review-2026-03-20.md`, `packages/cli/src/commands/backlog/init.ts`, `packages/cli/src/commands/backlog/init.test.ts`, `packages/cli/src/commands/backlog/regenerate-index.test.ts`, `packages/cli/src/commands/backlog/index.test.ts`, `packages/cli/src/commands/backlog/index.ts`
-
-**Design alignment:** Not applicable (`design.md` is not present for quick mode).
-
-### Requirements Coverage
-
-| Requirement                                                                                                                        | Status      | Notes                                                                                                                                                                                                                                                                                                                                  |
-| ---------------------------------------------------------------------------------------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Persist the scaffolded `items/` and `archived/` directories across git commit/clone round-trips                                    | implemented | `initializeBacklog()` now seeds `items/.gitkeep` and `archived/.gitkeep` without overwriting existing placeholders (`packages/cli/src/commands/backlog/init.ts:70`). `init.test.ts` covers creation and rerun preservation (`packages/cli/src/commands/backlog/init.test.ts:19`, `packages/cli/src/commands/backlog/init.test.ts:92`). |
-| Freshly scaffolded backlog roots remain usable with `oat backlog regenerate-index` after clone, without rerunning `init`           | implemented | The new git round-trip regression commits and clones a scaffolded repo, then runs `regenerateBacklogIndex()` successfully against the clone (`packages/cli/src/commands/backlog/regenerate-index.test.ts:183`).                                                                                                                        |
-| Add command-level coverage for the `oat backlog init` action path                                                                  | implemented | `index.test.ts` now runs the Commander action through `createBacklogCommand()` rather than only testing the helper (`packages/cli/src/commands/backlog/index.test.ts:77`).                                                                                                                                                             |
-| Verify default root resolution, `--backlog-root` override, text output, JSON output, and `process.exitCode` for `oat backlog init` | implemented | The command harness asserts default project-root resolution, override behavior, text output, JSON payload shape, and zero exit code (`packages/cli/src/commands/backlog/index.test.ts:77`, `packages/cli/src/commands/backlog/index.test.ts:93`, `packages/cli/src/commands/backlog/index.test.ts:113`).                               |
-
-### Extra Work (not in declared requirements)
-
-None
-
-## Verification Commands
-
-Run these to verify the implementation:
-
-```bash
-pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts
-```
-
-## Recommended Next Step
-
-Run the `oat-project-review-receive` skill to convert findings into plan tasks.
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index 0a5e24bb0..5af6b879c 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -7,26 +7,26 @@ oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop li
 oat_hill_completed: [] # Progress: which HiLL checkpoints have been completed
 oat_parallel_execution: false
 oat_phase: implement # Current phase: discovery | spec | design | plan | implement
-oat_phase_status: in_progress # Status: in_progress | complete
+oat_phase_status: complete # Status: in_progress | complete
 oat_execution_mode: single-thread # single-thread | subagent-driven
 oat_workflow_mode: quick # spec-driven | quick | import
 oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-20T23:31:02Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-21T00:07:18Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
 # Project State: backlog-init-command
 
-**Status:** Awaiting Final Re-Review
+**Status:** Implementation Complete
 **Started:** 2026-03-20
 **Last Updated:** 2026-03-20
 
 ## Current Phase
 
-Implementation - Review-fix tasks complete; awaiting final re-review.
+Implementation complete - final review passed.
 
 ## Artifacts
 
@@ -42,7 +42,7 @@ Implementation - Review-fix tasks complete; awaiting final re-review.
 - ✓ Plan complete
 - ✓ Initial implementation tasks complete
 - ✓ Review fixes complete
-- ⧗ Awaiting final re-review
+- ✓ Final review passed
 
 ## Blockers
 
@@ -50,4 +50,4 @@ None
 
 ## Next Milestone
 
-Run `oat-project-review-provide code final` for the final re-review.
+Run `oat-project-pr-final` to prepare the PR.

From 135945fc2c5388e699eea83a544c9b78d3c92258 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:09:11 -0500
Subject: [PATCH 17/21] chore(backlog-init-command): prepare final PR

---
 .oat/projects/shared/backlog-init-command/state.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index 5af6b879c..ae0d55d01 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -14,7 +14,7 @@ oat_workflow_origin: native # native | imported
 oat_docs_updated: null # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-21T00:07:18Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-21T00:09:03Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 
@@ -50,4 +50,4 @@ None
 
 ## Next Milestone
 
-Run `oat-project-pr-final` to prepare the PR.
+Run `oat-project-complete`.

From c25579b7cfdb235470b0d2c343926666097c63d0 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:23:42 -0500
Subject: [PATCH 18/21] docs(backlog-init-command): update documentation from
 project artifacts

---
 .oat/repo/reference/current-state.md      | 5 +++--
 apps/oat-docs/docs/guide/cli-reference.md | 3 ++-
 apps/oat-docs/docs/quickstart.md          | 2 ++
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/.oat/repo/reference/current-state.md b/.oat/repo/reference/current-state.md
index 94e1b434f..7719ff742 100644
--- a/.oat/repo/reference/current-state.md
+++ b/.oat/repo/reference/current-state.md
@@ -130,7 +130,7 @@ This document is a birdseye view of where OAT is _right now_ in `open-agent-tool
   - `oat providers list`, `oat providers inspect`, `oat providers set`
   - `oat cleanup project`, `oat cleanup artifacts`
   - `oat instructions validate`, `oat instructions sync`
-  - `oat backlog generate-id`, `oat backlog regenerate-index`
+  - `oat backlog init`, `oat backlog generate-id`, `oat backlog regenerate-index`
   - `oat tools list`, `oat tools outdated`, `oat tools info`, `oat tools update`, `oat tools remove`, `oat tools install` (packs: core, ideas, workflows, utility, project-management, research)
 - Provider config model:
   - Project provider enablement lives in `.oat/sync/config.json` (`providers.<name>.enabled`).
@@ -232,7 +232,8 @@ Backlog/reference workflow quickstart:
 
 1. Create or update backlog items:
    - `oat-pjm-add-backlog-item`
-2. Regenerate managed backlog metadata directly when needed:
+2. Scaffold or regenerate managed backlog metadata directly when needed:
+   - `oat backlog init`
    - `oat backlog generate-id <filename>`
    - `oat backlog regenerate-index`
 3. Refresh repo references:
diff --git a/apps/oat-docs/docs/guide/cli-reference.md b/apps/oat-docs/docs/guide/cli-reference.md
index db374e9ed..49d858494 100644
--- a/apps/oat-docs/docs/guide/cli-reference.md
+++ b/apps/oat-docs/docs/guide/cli-reference.md
@@ -67,11 +67,12 @@ See [Tool Packs](tool-packs.md) for the pack lifecycle and compatibility notes.
 
 Use the `oat backlog` group when you want direct CLI support for the file-backed backlog under `.oat/repo/reference/backlog/`.
 
+- `oat backlog init` - scaffold `.oat/repo/reference/backlog/` with starter files and directories for a fresh repo
 - `oat backlog generate-id <filename>` - generate a unique backlog ID from a filename seed
 - `oat backlog generate-id <filename> --created-at <timestamp>` - generate a reproducible ID for a known creation timestamp
 - `oat backlog regenerate-index` - rebuild the managed backlog index table from item frontmatter
 
-This command group is primarily used by the `oat-pjm-*` project-management skills, but it is also available directly when you need to inspect or repair backlog metadata by hand.
+Run `oat backlog init` first when the local backlog scaffold does not exist yet in a fresh repo. This command group is primarily used by the `oat-pjm-*` project-management skills, but it is also available directly when you need to inspect or repair backlog metadata by hand.
 
 ### `oat local ...`
 
diff --git a/apps/oat-docs/docs/quickstart.md b/apps/oat-docs/docs/quickstart.md
index 1d4ded1e3..231971e8a 100644
--- a/apps/oat-docs/docs/quickstart.md
+++ b/apps/oat-docs/docs/quickstart.md
@@ -87,6 +87,7 @@ pnpm run cli -- docs init --app-name my-docs
 pnpm run cli -- docs nav sync --target-dir apps/my-docs
 
 # Manage the file-backed backlog directly
+pnpm run cli -- backlog init
 pnpm run cli -- backlog generate-id add-webhook-support --created-at 2026-03-15T14:30:00Z
 pnpm run cli -- backlog regenerate-index
 
@@ -113,6 +114,7 @@ oat instructions sync
 oat remove skills --pack utility
 oat doctor --scope all
 oat project new my-project --mode spec-driven
+oat backlog init
 oat backlog regenerate-index
 ```
 

From be0a0d8fcc49b3e0ac8d5d3aa1b0644ea1628c58 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:23:44 -0500
Subject: [PATCH 19/21] chore(backlog-init-command): mark docs updated

---
 .oat/projects/shared/backlog-init-command/state.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
index ae0d55d01..a423a4fee 100644
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ b/.oat/projects/shared/backlog-init-command/state.md
@@ -11,10 +11,10 @@ oat_phase_status: complete # Status: in_progress | complete
 oat_execution_mode: single-thread # single-thread | subagent-driven
 oat_workflow_mode: quick # spec-driven | quick | import
 oat_workflow_origin: native # native | imported
-oat_docs_updated: null # null | skipped | complete — documentation sync status
+oat_docs_updated: complete # null | skipped | complete — documentation sync status
 oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
 oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-21T00:09:03Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
+oat_project_state_updated: '2026-03-21T00:23:33Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
 oat_generated: false
 ---
 

From f730be5fdcd630819480070d652664a3e852db91 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:26:50 -0500
Subject: [PATCH 20/21] chore(oat): complete project lifecycle for
 backlog-init-command

---
 .../shared/backlog-init-command/discovery.md  | 120 -----
 .../backlog-init-command/implementation.md    | 481 ------------------
 .../shared/backlog-init-command/plan.md       | 285 -----------
 .../shared/backlog-init-command/state.md      |  53 --
 4 files changed, 939 deletions(-)
 delete mode 100644 .oat/projects/shared/backlog-init-command/discovery.md
 delete mode 100644 .oat/projects/shared/backlog-init-command/implementation.md
 delete mode 100644 .oat/projects/shared/backlog-init-command/plan.md
 delete mode 100644 .oat/projects/shared/backlog-init-command/state.md

diff --git a/.oat/projects/shared/backlog-init-command/discovery.md b/.oat/projects/shared/backlog-init-command/discovery.md
deleted file mode 100644
index 1f92ec207..000000000
--- a/.oat/projects/shared/backlog-init-command/discovery.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-oat_status: complete
-oat_ready_for: oat-project-plan
-oat_blockers: []
-oat_last_updated: 2026-03-20
-oat_generated: false
----
-
-# Discovery: backlog-init-command
-
-## Initial Request
-
-Add an explicit backlog scaffold CLI command for repositories that have OAT installed but do not yet have the file-backed backlog structure under `.oat/repo/reference/backlog/`. The immediate trigger was trying to use the new project-management flow in a fresh repo and finding that the backlog directories and starter files did not exist.
-
-## Clarifying Questions
-
-### Question 1: Scope of the fix
-
-**Q:** Should the fix include automatic skill behavior changes, or stay at the CLI layer?
-**A:** Keep it to a new CLI command for now and do not update `oat-pjm-*` skills.
-**Decision:** This project will add `oat backlog init` only. Skill behavior stays unchanged.
-
-### Question 2: Future PM direction
-
-**Q:** Should the local backlog scaffold be treated as mandatory project-management initialization?
-**A:** Not yet. Future Linear/Jira-backed project management may not need a local scaffold at all.
-**Decision:** Keep the command backlog-scoped and explicit. Do not introduce PJM-specific or automatic initialization semantics in this task.
-
-## Options Considered
-
-### Option A: Explicit `oat backlog init` command
-
-**Description:** Add a dedicated backlog CLI subcommand that creates the canonical backlog directories and starter markdown files on demand.
-
-**Pros:**
-
-- Keeps the setup behavior explicit and discoverable.
-- Avoids coupling local-only setup assumptions into skills that may later support remote PM flows.
-- Can be reused by any backlog-related workflow, not just add-item flows.
-
-**Cons:**
-
-- Requires users to learn one additional setup command.
-
-**Chosen:** A
-
-**Summary:** Use an explicit, idempotent `oat backlog init` command as the initial fix. It solves the immediate onboarding gap without overcommitting to a local-only PM model.
-
-### Option B: Auto-scaffold from skills or other backlog commands
-
-**Description:** Detect a missing backlog scaffold at runtime and create it implicitly from `oat-pjm-add-backlog-item` or other backlog operations.
-
-**Pros:**
-
-- Reduces manual setup steps for first-time users.
-- Can feel smoother in purely local workflows.
-
-**Cons:**
-
-- Bakes local scaffold assumptions into higher-level flows prematurely.
-- Makes repo mutations less explicit.
-- Risks awkward behavior when future remote PM integrations do not want the same local scaffold.
-
-**Chosen:** Not now
-
-**Summary:** This remains a reasonable future enhancement, but it is intentionally deferred until the local-vs-remote PM model is clearer.
-
-## Key Decisions
-
-1. **Entry point:** Add `oat backlog init` as a first-class CLI command under the existing backlog command group.
-2. **Scope boundary:** Do not update `oat-pjm-add-backlog-item` or other skills in this project.
-3. **Scaffold behavior:** The command should create the canonical backlog directory structure and starter files, and be safe to rerun without clobbering existing curated content.
-
-## Constraints
-
-- This is a new follow-on task after the prior project-management backlog work was already merged.
-- The solution should not assume local file-backed backlog setup is always required for future project-management integrations.
-- The command must fit the existing backlog CLI surface and testing conventions.
-
-## Success Criteria
-
-- `oat backlog init` creates `.oat/repo/reference/backlog/`, `items/`, `archived/`, `index.md`, and `completed.md` when they are missing.
-- The generated starter files use the existing managed index markers and starter sections expected by current backlog tooling.
-- Re-running the command is idempotent and does not overwrite existing curated backlog content.
-- Freshly scaffolded backlog roots work with existing backlog commands such as `oat backlog regenerate-index`.
-
-## Out of Scope
-
-- Automatic scaffold creation from `oat-pjm-*` skills or other backlog commands.
-- Any remote Linear/Jira synchronization or project-management integration changes.
-- Reworking the broader project-management onboarding flow beyond this explicit command.
-
-## Deferred Ideas
-
-- Auto-initialize the backlog scaffold from add-item or review flows once the local-vs-remote PM contract is clearer.
-- Introduce a broader PM initialization story later if remote-backed project-management still benefits from partial local scaffolding.
-
-## Open Questions
-
-- **Future PM model:** Whether later Linear/Jira-backed flows should reuse this local scaffold, partially reuse it, or bypass it entirely.
-
-## Assumptions
-
-- The canonical starter content for `index.md` and `completed.md` should match the current file-backed backlog structure already used in this repo.
-- A backlog-scoped command is the cleanest current entry point because the missing assets live under `.oat/repo/reference/backlog/`, not inside the installed skill pack.
-
-## Risks
-
-- **Scope creep toward full PM setup:** The command could grow into a broader local project-management initializer.
-  - **Likelihood:** Medium
-  - **Impact:** Medium
-  - **Mitigation Ideas:** Keep the command narrowly scoped to backlog files and directories only.
-- **Starter-content drift:** The scaffolded `index.md` and `completed.md` could diverge from the current canonical backlog structure over time.
-  - **Likelihood:** Medium
-  - **Impact:** Medium
-  - **Mitigation Ideas:** Add focused tests that assert the expected managed markers and starter sections.
-
-## Next Steps
-
-Proceed directly to `plan.md`. The request is well-understood, scoped to a single CLI feature, and does not need a separate lightweight design step.
diff --git a/.oat/projects/shared/backlog-init-command/implementation.md b/.oat/projects/shared/backlog-init-command/implementation.md
deleted file mode 100644
index 54de22410..000000000
--- a/.oat/projects/shared/backlog-init-command/implementation.md
+++ /dev/null
@@ -1,481 +0,0 @@
----
-oat_status: complete
-oat_ready_for: null
-oat_blockers: []
-oat_last_updated: 2026-03-20
-oat_current_task_id: null
-oat_generated: false
----
-
-# Implementation: backlog-init-command
-
-**Started:** 2026-03-20
-**Last Updated:** 2026-03-20
-
-> This document is used to resume interrupted implementation sessions.
->
-> Conventions:
->
-> - `oat_current_task_id` always points at the **next plan task to do** (not the last completed task).
-> - When all plan tasks are complete, set `oat_current_task_id: null`.
-> - Reviews are **not** plan tasks. Track review status in `plan.md` under `## Reviews` (e.g., `| final | code | passed | ... |`).
-> - Keep phase/task statuses consistent with the Progress Overview table so restarts resume correctly.
-> - Before running the `oat-project-pr-final` skill, ensure `## Final Summary (for PR/docs)` is filled with what was actually implemented.
-
-## Progress Overview
-
-| Phase   | Status   | Tasks | Completed |
-| ------- | -------- | ----- | --------- |
-| Phase 1 | complete | 2     | 2/2       |
-| Phase 2 | complete | 1     | 1/1       |
-| Phase 3 | complete | 2     | 2/2       |
-
-**Total:** 5/5 tasks completed
-
----
-
-## Phase 1: Backlog Scaffold Command
-
-**Status:** complete
-**Started:** 2026-03-20
-
-### Phase Summary (fill when phase is complete)
-
-**Outcome (what changed):**
-
-- Added the reusable backlog scaffold helper and surfaced it through a new `oat backlog init` CLI command.
-- Documented the new scaffold entry point in the backlog help output and added dedicated help snapshot coverage.
-- Finished the first implementation phase without adding any skill-side auto-init behavior.
-
-**Key files touched:**
-
-- `packages/cli/src/commands/backlog/init.ts` - backlog scaffold helper and starter content
-- `packages/cli/src/commands/backlog/index.ts` - new `backlog init` command wiring
-- `packages/cli/src/commands/backlog/init.test.ts` - initializer coverage
-- `packages/cli/src/commands/help-snapshots.test.ts` - help coverage for the new command surface
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`; `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
-- Result: Pass; initializer tests and help snapshots both succeeded
-
-**Notes / Decisions:**
-
-- Kept the feature backlog-scoped and explicit; no skill auto-scaffold behavior was introduced.
-- Reused the existing backlog root resolution path so all backlog commands share the same lookup semantics.
-
-### Task p01-t01: Implement backlog scaffold initializer
-
-**Status:** completed
-**Commit:** 1db39dd6
-
-**Outcome (required when completed):**
-
-- Added an `initializeBacklog()` helper that creates the backlog root, `items/`, and `archived/` directories.
-- Seeded canonical starter content for `index.md` and `completed.md` while preserving existing files on rerun.
-- Added targeted tests for fresh-root scaffolding and rerun idempotence.
-
-**Files changed:**
-
-- `packages/cli/src/commands/backlog/init.ts` - added the backlog scaffold helper and starter content
-- `packages/cli/src/commands/backlog/init.test.ts` - added focused coverage for scaffold creation and no-overwrite reruns
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
-- Result: Pass; both initializer tests passed after adding the helper implementation
-
-**Notes / Decisions:**
-
-- Seeded the managed index section with the same empty-table shape used by the existing backlog index regeneration flow.
-- Treated `index.md` and `completed.md` as create-if-missing files so reruns do not erase curated edits.
-
----
-
-### Task p01-t02: Wire `oat backlog init` into the CLI
-
-**Status:** completed
-**Commit:** dcb2b50e
-
-**Outcome (required when completed):**
-
-- Added `oat backlog init` to the backlog command group with standard text and JSON output.
-- Exposed `--backlog-root <path>` for explicit scaffold targeting when needed.
-- Added help snapshot coverage for both `oat backlog --help` and `oat backlog init --help`.
-
-**Files changed:**
-
-- `packages/cli/src/commands/backlog/index.ts` - wired the new init subcommand into the CLI
-- `packages/cli/src/commands/help-snapshots.test.ts` - added help expectations for the new backlog scaffold command
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
-- Result: Pass; help output matches the updated snapshots
-
-**Notes / Decisions:**
-
-- Used the same `resolveBacklogRoot()` helper as `generate-id` and `regenerate-index` to keep path behavior consistent.
-
----
-
-## Phase 2: Compatibility Coverage
-
-**Status:** complete
-**Started:** 2026-03-20
-
-### Task p02-t01: Add regression coverage for scaffold compatibility
-
-**Status:** completed
-**Commit:** cee41cca
-
-**Outcome (required when completed):**
-
-- Added regression coverage that proves a freshly scaffolded backlog root works with `regenerate-index`.
-- Added a focused idempotence test that preserves curated overview edits across repeated `initializeBacklog()` runs.
-- Confirmed the scaffolded backlog shape was already compatible, so no additional production code changes were needed in this phase.
-
-**Files changed:**
-
-- `packages/cli/src/commands/backlog/init.test.ts` - added curated-overview preservation coverage
-- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - added scaffold-compatibility regression coverage
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
-- Result: Pass; targeted backlog coverage and workspace type-check both succeeded
-
-**Notes / Decisions:**
-
-- The compatibility regressions passed without production changes, which confirmed the phase-1 scaffold content already matches `regenerate-index` expectations.
-
----
-
-## Phase 3: Review Fixes (final)
-
-**Status:** complete
-**Started:** 2026-03-20
-
-### Phase Summary (fill when phase is complete)
-
-**Outcome (what changed):**
-
-- Persisted the scaffolded backlog directory shape across git commit/clone round-trips by seeding `.gitkeep` placeholders.
-- Added command-level coverage for the actual `oat backlog init` action path, including default root resolution, `--backlog-root`, text output, JSON output, and exit-code behavior.
-- Closed both final-review findings without widening the feature scope beyond backlog scaffolding and verification.
-
-**Key files touched:**
-
-- `packages/cli/src/commands/backlog/init.ts` - seeds tracked placeholders for empty scaffold directories
-- `packages/cli/src/commands/backlog/init.test.ts` - verifies placeholder creation and rerun preservation
-- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - covers git round-trip compatibility
-- `packages/cli/src/commands/backlog/index.test.ts` - exercises the `backlog init` command surface
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-- Run: `pnpm test && pnpm lint && pnpm type-check && pnpm build`
-- Result: Pass; targeted backlog coverage and repo-wide verification all succeeded
-
-**Notes / Decisions:**
-
-- The command surface was already testable with dependency injection, so `p03-t02` required no production code changes.
-
-### Task p03-t01: (review) Preserve empty backlog directories across git clone
-
-**Status:** completed
-**Commit:** bf784cc7
-
-**Outcome (required when completed):**
-
-- Added `.gitkeep` placeholders to the scaffolded `items/` and `archived/` directories so the canonical backlog shape survives git commits and clones.
-- Added regression coverage that commits and clones a scaffolded repo before running `regenerate-index`, proving the backlog remains usable without rerunning `init`.
-
-**Files changed:**
-
-- `packages/cli/src/commands/backlog/init.ts` - seeds tracked placeholders for empty scaffold directories
-- `packages/cli/src/commands/backlog/init.test.ts` - verifies placeholder creation and rerun preservation
-- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - covers the git round-trip compatibility path
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-- Result: Pass; targeted scaffold and round-trip regressions succeeded
-
-**Notes / Decisions:**
-
-- Used `.gitkeep` so empty directories remain versionable without changing runtime behavior; `regenerate-index` already ignores non-Markdown files.
-
----
-
-### Task p03-t02: (review) Add command-level coverage for `oat backlog init`
-
-**Status:** completed
-**Commit:** 009f0619
-
-**Outcome (required when completed):**
-
-- Added a dedicated command harness for `oat backlog init` that exercises the Commander action instead of only the helper.
-- Verified default backlog-root resolution, `--backlog-root` override behavior, text output, JSON payload shape, and `process.exitCode`.
-
-**Files changed:**
-
-- `packages/cli/src/commands/backlog/index.test.ts` - covers the `backlog init` command surface and output contract
-
-**Verification:**
-
-- Run: `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-- Result: Pass; command-level and helper-level backlog tests all succeeded
-
-**Notes / Decisions:**
-
-- Kept the production implementation unchanged because the existing dependency seams were sufficient for command-level testing.
-
----
-
-## Review Received: final
-
-**Date:** 2026-03-20
-**Review artifact:** reviews/archived/final-review-2026-03-20.md
-
-**Findings:**
-
-- Critical: 1
-- Important: 1
-- Medium: 0
-- Minor: 0
-
-**Disposition:**
-
-- `C1` (empty scaffold directories are not persisted in git) → converted to `p03-t01`
-- `I1` (`oat backlog init` command wiring/output path is untested) → converted to `p03-t02`
-
-**Deferred Findings Disposition (Final Scope):**
-
-- Deferred Medium count: 0 (gate satisfied)
-- Minor findings count: 0 (gate satisfied)
-
-**New tasks added:** p03-t01, p03-t02
-
-**Next:** Request final re-review via `oat-project-review-provide code final`.
-
-After the fix tasks are complete:
-
-- The final review row is `fixes_completed`
-- Re-run `oat-project-review-provide code final`, then `oat-project-review-receive` to reach `passed`
-
----
-
-## Review Received: final (v2 re-review — PASSED)
-
-**Date:** 2026-03-20
-**Review artifact:** reviews/archived/final-review-2026-03-20-v2.md
-
-**Findings:**
-
-- Critical: 0
-- Important: 0
-- Medium: 0
-- Minor: 0
-
-**Result:** PASSED — no new findings. The prior final-review issues are resolved by `p03-t01` and `p03-t02`.
-
-**Final-scope gates:**
-
-- Deferred Medium gate: satisfied (0 deferred mediums)
-- Minor findings gate: satisfied (0 minor findings in the passing re-review)
-
-**Next:** Create the final PR via `oat-project-pr-final`.
-
----
-
-## Orchestration Runs
-
-> This section is used by `oat-project-subagent-implement` to log parallel execution runs.
-> Each run appends a new subsection — never overwrite prior entries.
-> For single-thread execution (via `oat-project-implement`), this section remains empty.
-
-<!-- orchestration-runs-start -->
-<!-- orchestration-runs-end -->
-
----
-
-## Implementation Log
-
-Chronological log of implementation progress.
-
-### 2026-03-20
-
-**Session Start:** planning
-
-- [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
-- [x] p01-t02: Wire `oat backlog init` into the CLI - dcb2b50e
-- [ ] p02-t01: Add regression coverage for scaffold compatibility - pending
-
-**What changed (high level):**
-
-- Scaffolded the quick-mode project and captured discovery for an explicit `oat backlog init` command.
-- Generated an execution-ready three-task plan focused on CLI scaffolding and compatibility coverage.
-- Implemented the backlog scaffold helper and tests for fresh-root creation plus rerun idempotence.
-
-**Decisions:**
-
-- Keep the feature backlog-scoped and explicit; do not update `oat-pjm-*` skills in this project.
-- Skip lightweight design because the request is well-understood and does not have unresolved architecture questions.
-
-**Follow-ups / TODO:**
-
-- Confirm exact starter content in `index.md` and `completed.md` against the current canonical backlog structure during implementation.
-
-**Blockers:**
-
-- None
-
-**Session End:** planning complete
-
----
-
-### 2026-03-20
-
-**Session Start:** implementation
-
-- [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
-- [x] p01-t02: Wire `oat backlog init` into the CLI - dcb2b50e
-- [ ] p02-t01: Add regression coverage for scaffold compatibility - next
-
-**What changed (high level):**
-
-- Added the reusable backlog scaffold helper that seeds canonical starter files.
-- Added targeted tests proving the helper creates the directories and preserves existing file content on rerun.
-
-**Decisions:**
-
-- Use create-if-missing semantics for `index.md` and `completed.md` so the future command is idempotent by default.
-
-**Follow-ups / TODO:**
-
-- Add regression coverage proving a freshly scaffolded backlog root works with `regenerate-index`.
-
-**Blockers:**
-
-- None
-
-**Session End:** task complete
-
----
-
-### 2026-03-20
-
-**Session Start:** implementation
-
-- [x] p01-t01: Implement backlog scaffold initializer - 1db39dd6
-- [x] p01-t02: Wire `oat backlog init` into the CLI - dcb2b50e
-- [ ] p02-t01: Add regression coverage for scaffold compatibility - next
-
-**What changed (high level):**
-
-- Added the `oat backlog init` command and documented it in the backlog help surface.
-- Completed phase 1 and rolled directly into phase 2 because the only configured checkpoint is `p02`.
-
-**Decisions:**
-
-- Keep CLI output aligned with the other backlog commands by returning `status` and `backlogRoot` in JSON mode.
-
-**Blockers:**
-
-- None
-
-**Session End:** phase 1 complete
-
----
-
-### 2026-03-20
-
-**Session Start:** implementation
-
-- [x] p02-t01: Add regression coverage for scaffold compatibility - cee41cca
-
-**What changed (high level):**
-
-- Added compatibility coverage proving a freshly scaffolded backlog root works with the existing index regeneration flow.
-- Added a realistic idempotence test that preserves curated overview edits on rerun.
-- Completed all planned implementation tasks and passed the full verification suite.
-
-**Decisions:**
-
-- Keep phase 2 test-only; the new regressions showed the scaffold contract was already correct.
-
-**Follow-ups / TODO:**
-
-- Request final review before PR work.
-
-**Blockers:**
-
-- None
-
-**Session End:** implementation complete
-
----
-
-## Deviations from Plan
-
-Document any deviations from the original plan.
-
-| Task | Planned | Actual | Reason |
-| ---- | ------- | ------ | ------ |
-| -    | -       | -      | -      |
-
-## Test Results
-
-Track test execution during implementation.
-
-| Phase | Tests Run | Passed | Failed | Coverage |
-| ----- | --------- | ------ | ------ | -------- |
-| 1     | -         | -      | -      | -        |
-| 2     | -         | -      | -      | -        |
-
-## Final Summary (for PR/docs)
-
-**What shipped:**
-
-- Added an explicit `oat backlog init` command for scaffolding the canonical local backlog directory structure.
-- Added a reusable initializer that creates `items/`, `archived/`, `index.md`, and `completed.md` without overwriting existing backlog files on rerun, and now seeds `.gitkeep` placeholders so the scaffold survives git round-trips.
-- Added regression coverage proving the scaffolded backlog shape is compatible with `oat backlog regenerate-index`, preserves curated overview edits, and remains valid after commit/clone.
-- Added command-level coverage for the `oat backlog init` action path and its text/JSON output contract.
-
-**Behavioral changes (user-facing):**
-
-- Users can now run `oat backlog init` in a fresh repo to create the starter backlog structure before using other file-backed backlog flows.
-- Re-running the command leaves curated backlog content intact instead of resetting the backlog index or completed summary files.
-- Repositories that commit a freshly initialized backlog now retain the empty `items/` and `archived/` directories after clone.
-
-**Key files / modules:**
-
-- `packages/cli/src/commands/backlog/init.ts` - backlog scaffold helper and starter file content
-- `packages/cli/src/commands/backlog/index.ts` - `oat backlog init` command wiring
-- `packages/cli/src/commands/backlog/index.test.ts` - command-level `backlog init` coverage
-- `packages/cli/src/commands/backlog/init.test.ts` - scaffold creation and idempotence coverage
-- `packages/cli/src/commands/backlog/regenerate-index.test.ts` - scaffold compatibility coverage
-
-**Verification performed:**
-
-- `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
-- `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
-- `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
-- `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-- `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-- `pnpm test`
-- `pnpm lint`
-- `pnpm type-check`
-- `pnpm build`
-
-**Design deltas (if any):**
-
-- None expected
-
-## References
-
-- Plan: `plan.md`
-- Design: `design.md`
-- Spec: `spec.md`
diff --git a/.oat/projects/shared/backlog-init-command/plan.md b/.oat/projects/shared/backlog-init-command/plan.md
deleted file mode 100644
index ed15461bd..000000000
--- a/.oat/projects/shared/backlog-init-command/plan.md
+++ /dev/null
@@ -1,285 +0,0 @@
----
-oat_status: complete
-oat_ready_for: oat-project-implement
-oat_blockers: []
-oat_last_updated: 2026-03-20
-oat_phase: plan
-oat_phase_status: complete
-oat_plan_hill_phases: ['p02'] # phases to pause AFTER completing (empty = every phase)
-oat_plan_source: quick # spec-driven | quick | imported
-oat_import_reference: null # e.g., references/imported-plan.md
-oat_import_source_path: null # original source path provided by user
-oat_import_provider: null # codex | cursor | claude | null
-oat_generated: false
----
-
-# Implementation Plan: backlog-init-command
-
-> Execute this plan using `oat-project-implement` (sequential) or `oat-project-subagent-implement` (parallel), with phase checkpoints and review gates.
-
-**Goal:** Add an explicit, idempotent `oat backlog init` command that scaffolds the canonical local backlog directory structure and starter files for repositories that do not already have them.
-
-**Architecture:** Extend the existing backlog CLI group with a scaffold command that resolves a backlog root, creates the missing directories and starter markdown files, and leaves existing curated content untouched on rerun. Use the current backlog file structure and managed index markers as the source of truth.
-
-**Tech Stack:** TypeScript ESM, Commander, Node.js 22, Vitest, pnpm workspaces
-
-**Commit Convention:** `{type}({scope}): {description}` - e.g., `feat(p01-t01): add backlog scaffold initializer`
-
-## Planning Checklist
-
-- [x] Deferred HiLL checkpoint confirmation to `oat-project-implement`
-
----
-
-## Phase 1: Backlog Scaffold Command
-
-Implement the new scaffold command and the filesystem helper it relies on.
-
-### Task p01-t01: Implement backlog scaffold initializer
-
-**Files:**
-
-- Create: `packages/cli/src/commands/backlog/init.ts`
-- Create: `packages/cli/src/commands/backlog/init.test.ts`
-
-**Step 1: Write test (RED)**
-
-Add focused tests for a fresh backlog root that assert:
-
-- `items/` and `archived/` are created
-- `index.md` is seeded with:
-  - `# OAT Backlog Index`
-  - `## Curated Overview`
-  - `<!-- OAT BACKLOG-INDEX -->` / `<!-- END OAT BACKLOG-INDEX -->`
-  - `## Notes`
-- `completed.md` is seeded with:
-  - `# OAT Backlog Completed`
-  - `## Entry Format`
-  - `## Completed Items`
-- rerunning the initializer does not overwrite existing file contents
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
-Expected: Test fails (RED)
-
-**Step 2: Implement (GREEN)**
-
-Implement an initializer that creates the backlog root when missing and writes starter content only for files that do not yet exist. Preserve any existing `index.md` or `completed.md` content on rerun.
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
-Expected: Test passes (GREEN)
-
-**Step 3: Refactor**
-
-Extract reusable starter content/constants as needed so the command remains readable and future content drift is easy to manage.
-
-**Step 4: Verify**
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts`
-Expected: No errors
-
-**Step 5: Commit**
-
-```bash
-git add packages/cli/src/commands/backlog/init.ts packages/cli/src/commands/backlog/init.test.ts
-git commit -m "feat(p01-t01): add backlog scaffold initializer"
-```
-
----
-
-### Task p01-t02: Wire `oat backlog init` into the CLI
-
-**Files:**
-
-- Modify: `packages/cli/src/commands/backlog/index.ts`
-- Modify: `packages/cli/src/commands/help-snapshots.test.ts`
-
-**Step 1: Write test (RED)**
-
-Add or update help snapshot coverage so:
-
-- `oat backlog --help` lists `init`
-- `oat backlog init --help` documents the command and `--backlog-root <path>`
-
-**Step 2: Implement (GREEN)**
-
-Register a new `init` subcommand under `createBacklogCommand()` that:
-
-- resolves the backlog root using the same root resolution pattern as the existing backlog commands
-- calls the initializer
-- reports the resulting backlog root in text and JSON modes
-
-**Step 3: Refactor**
-
-Keep shared backlog-root resolution and output behavior consistent with the existing `generate-id` and `regenerate-index` commands.
-
-**Step 4: Verify**
-
-Run: `pnpm --filter @oat/cli test -- src/commands/help-snapshots.test.ts`
-Expected: Updated snapshots pass
-
-**Step 5: Commit**
-
-```bash
-git add packages/cli/src/commands/backlog/index.ts packages/cli/src/commands/help-snapshots.test.ts
-git commit -m "feat(p01-t02): add backlog init command"
-```
-
----
-
-## Phase 2: Compatibility Coverage
-
-Prove that the new scaffold works cleanly with the existing backlog command surface and remains safe on rerun.
-
-### Task p02-t01: Add regression coverage for scaffold compatibility
-
-**Files:**
-
-- Modify: `packages/cli/src/commands/backlog/init.test.ts`
-- Modify: `packages/cli/src/commands/backlog/regenerate-index.test.ts`
-
-**Step 1: Write test (RED)**
-
-Add regression coverage that:
-
-- runs the scaffold against an empty backlog root and then successfully regenerates the index
-- verifies the managed table can be rewritten in the seeded `index.md`
-- proves rerunning `init` preserves existing curated overview edits instead of resetting the file
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-Expected: New regression cases fail (RED)
-
-**Step 2: Implement (GREEN)**
-
-Adjust scaffold content or helper behavior as needed so the seeded files are fully compatible with `regenerate-index` and safe for repeated invocation.
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-Expected: Tests pass (GREEN)
-
-**Step 3: Refactor**
-
-Tighten any duplicated test setup or scaffold text helpers while keeping the command contract unchanged.
-
-**Step 4: Verify**
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts src/commands/help-snapshots.test.ts && pnpm type-check`
-Expected: No errors
-
-**Step 5: Commit**
-
-```bash
-git add packages/cli/src/commands/backlog/init.test.ts packages/cli/src/commands/backlog/regenerate-index.test.ts packages/cli/src/commands/help-snapshots.test.ts
-git commit -m "test(p02-t01): cover backlog init compatibility"
-```
-
----
-
-## Phase 3: Review Fixes (final)
-
-Address the final review findings around git-persisted scaffold directories and command-level CLI coverage.
-
-### Task p03-t01: (review) Preserve empty backlog directories across git clone
-
-**Files:**
-
-- Modify: `packages/cli/src/commands/backlog/init.ts`
-- Modify: `packages/cli/src/commands/backlog/init.test.ts`
-- Modify: `packages/cli/src/commands/backlog/regenerate-index.test.ts`
-
-**Step 1: Understand the issue**
-
-Review finding: `oat backlog init` creates empty `items/` and `archived/` directories but does not seed tracked placeholders, so a committed/cloned scaffold can lose them and `oat backlog regenerate-index` then fails with `ENOENT`.
-Location: `packages/cli/src/commands/backlog/init.ts:69`
-
-**Step 2: Implement fix**
-
-Seed tracked placeholders such as `items/.gitkeep` and `archived/.gitkeep` when initializing a fresh scaffold, without disturbing existing directory contents. Add regression coverage that simulates the git round-trip and proves `regenerate-index` works without rerunning `init`.
-
-**Step 3: Verify**
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-Expected: All targeted backlog scaffold tests pass, including the clone-round-trip regression
-
-**Step 4: Commit**
-
-```bash
-git add packages/cli/src/commands/backlog/init.ts packages/cli/src/commands/backlog/init.test.ts packages/cli/src/commands/backlog/regenerate-index.test.ts
-git commit -m "fix(p03-t01): persist backlog scaffold directories in git"
-```
-
----
-
-### Task p03-t02: (review) Add command-level coverage for `oat backlog init`
-
-**Files:**
-
-- Create: `packages/cli/src/commands/backlog/index.test.ts`
-- Modify: `packages/cli/src/commands/backlog/index.ts` (only if testability hooks are needed)
-
-**Step 1: Understand the issue**
-
-Review finding: current tests cover the initializer helper and help snapshots, but do not execute the actual Commander action for `oat backlog init`, leaving root resolution and text/JSON output behavior unverified.
-Location: `packages/cli/src/commands/backlog/index.ts:66`
-
-**Step 2: Implement fix**
-
-Add command-level tests that run `backlog init` through the command surface with injected dependencies and assert default backlog-root resolution, `--backlog-root` override behavior, text output, JSON output `{ status: 'ok', backlogRoot }`, and `process.exitCode`. Make only the minimal production changes needed to support that harness.
-
-**Step 3: Verify**
-
-Run: `pnpm --filter @oat/cli test -- src/commands/backlog/index.test.ts src/commands/backlog/init.test.ts src/commands/backlog/regenerate-index.test.ts`
-Expected: Command-level and helper-level backlog tests all pass
-
-**Step 4: Commit**
-
-```bash
-git add packages/cli/src/commands/backlog/index.test.ts packages/cli/src/commands/backlog/index.ts packages/cli/src/commands/backlog/init.test.ts packages/cli/src/commands/backlog/regenerate-index.test.ts
-git commit -m "test(p03-t02): cover backlog init command surface"
-```
-
----
-
-## Reviews
-
-{Track reviews here after running the oat-project-review-provide and oat-project-review-receive skills.}
-
-{Keep both code + artifact rows below. Add additional code rows (p03, p04, etc.) as needed, but do not delete `spec`/`design`.}
-
-| Scope  | Type     | Status  | Date       | Artifact                                       |
-| ------ | -------- | ------- | ---------- | ---------------------------------------------- |
-| p01    | code     | pending | -          | -                                              |
-| p02    | code     | pending | -          | -                                              |
-| final  | code     | passed  | 2026-03-20 | reviews/archived/final-review-2026-03-20-v2.md |
-| spec   | artifact | pending | -          | -                                              |
-| design | artifact | pending | -          | -                                              |
-
-**Status values:** `pending` → `received` → `fixes_added` → `fixes_completed` → `passed`
-
-**Meaning:**
-
-- `received`: review artifact exists (not yet converted into fix tasks)
-- `fixes_added`: fix tasks were added to the plan (work queued)
-- `fixes_completed`: fix tasks implemented, awaiting re-review
-- `passed`: re-review run and recorded as passing (no Critical/Important)
-
----
-
-## Implementation Complete
-
-**Summary:**
-
-- Phase 1: 2 tasks - add the scaffold initializer and wire `oat backlog init` into the backlog CLI
-- Phase 2: 1 task - add compatibility and idempotence regression coverage
-- Phase 3: 2 tasks - address final review findings around git persistence and command-level coverage
-
-**Total: 5 tasks**
-
-Ready for PR and finalization.
-
----
-
-## References
-
-- Design: `design.md` (required in spec-driven mode; optional in quick/import mode)
-- Spec: `spec.md` (required in spec-driven mode; optional in quick/import mode)
-- Discovery: `discovery.md`
-- Imported Source: `references/imported-plan.md` (when `oat_plan_source: imported`)
diff --git a/.oat/projects/shared/backlog-init-command/state.md b/.oat/projects/shared/backlog-init-command/state.md
deleted file mode 100644
index a423a4fee..000000000
--- a/.oat/projects/shared/backlog-init-command/state.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-oat_current_task: null
-oat_last_commit: 009f0619
-oat_blockers: []
-associated_issues: [] # [{type: backlog|project|jira|linear, ref: "identifier"}]
-oat_hill_checkpoints: [] # Configured: which phases require human-in-the-loop lifecycle approval
-oat_hill_completed: [] # Progress: which HiLL checkpoints have been completed
-oat_parallel_execution: false
-oat_phase: implement # Current phase: discovery | spec | design | plan | implement
-oat_phase_status: complete # Status: in_progress | complete
-oat_execution_mode: single-thread # single-thread | subagent-driven
-oat_workflow_mode: quick # spec-driven | quick | import
-oat_workflow_origin: native # native | imported
-oat_docs_updated: complete # null | skipped | complete — documentation sync status
-oat_project_created: '2026-03-20T21:38:16.426Z' # ISO 8601 UTC timestamp — set once at project creation
-oat_project_completed: null # ISO 8601 UTC timestamp — set when project is completed/archived
-oat_project_state_updated: '2026-03-21T00:23:33Z' # ISO 8601 UTC timestamp — updated on every state.md mutation
-oat_generated: false
----
-
-# Project State: backlog-init-command
-
-**Status:** Implementation Complete
-**Started:** 2026-03-20
-**Last Updated:** 2026-03-20
-
-## Current Phase
-
-Implementation complete - final review passed.
-
-## Artifacts
-
-- **Discovery:** `discovery.md` (complete)
-- **Spec:** N/A (quick mode)
-- **Design:** N/A (quick mode)
-- **Plan:** `plan.md` (complete — 5 tasks across 3 phases, including review fixes)
-- **Implementation:** `implementation.md` (complete — all planned and review-fix tasks finished)
-
-## Progress
-
-- ✓ Discovery complete
-- ✓ Plan complete
-- ✓ Initial implementation tasks complete
-- ✓ Review fixes complete
-- ✓ Final review passed
-
-## Blockers
-
-None
-
-## Next Milestone
-
-Run `oat-project-complete`.

From e13fb6046ab7ba8634e75c2a55344fec471d08e5 Mon Sep 17 00:00:00 2001
From: Thomas Stang <thomas.stang@voxmedia.com>
Date: Fri, 20 Mar 2026 19:32:32 -0500
Subject: [PATCH 21/21] chore(oat): clarify project completion skill guidance

---
 .agents/skills/oat-project-complete/SKILL.md  | 16 ++++++++++--
 .oat/repo/reference/backlog/index.md          |  3 ++-
 .../items/project-complete-cli-helper.md      | 26 +++++++++++++++++++
 3 files changed, 42 insertions(+), 3 deletions(-)
 create mode 100644 .oat/repo/reference/backlog/items/project-complete-cli-helper.md

diff --git a/.agents/skills/oat-project-complete/SKILL.md b/.agents/skills/oat-project-complete/SKILL.md
index 08d9a95dd..68004c156 100644
--- a/.agents/skills/oat-project-complete/SKILL.md
+++ b/.agents/skills/oat-project-complete/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: oat-project-complete
-version: 1.3.0
+version: 1.3.1
 description: Use when all implementation work is finished and the project is ready to close. Marks the OAT project lifecycle as complete.
 disable-model-invocation: true
 user-invocable: true
@@ -192,7 +192,7 @@ Rules:
 
 ### Step 5: Set Lifecycle Complete
 
-Update state.md frontmatter to add/update `oat_lifecycle: complete` and set completion timestamp:
+Update `state.md` frontmatter to add/update `oat_lifecycle: complete` and set completion timestamps:
 
 ```bash
 STATE_FILE="${PROJECT_PATH}/state.md"
@@ -216,6 +216,18 @@ sed -E "s/^oat_project_state_updated:.*/oat_project_state_updated: \"$NOW_UTC\"/
 mv "$STATE_FILE.tmp" "$STATE_FILE"
 ```
 
+Then update the markdown body in `state.md` so the completion state is explicit and does not rely on reference lookups:
+
+- Set `**Status:** Complete`
+- Set `**Last Updated:**` to the completion date in `YYYY-MM-DD`
+- In `## Current Phase`, replace the body with:
+  - `Lifecycle complete; archived locally` when the project is archived in Step 8
+  - `Lifecycle complete` when the project is completed without archive
+- In `## Progress`, preserve the existing completed workflow/review bullets and add `- ✓ Project lifecycle complete` if it is not already present
+- In `## Next Milestone`, replace the body with `None. Project complete.`
+
+Do not infer these body mutations from other archived projects. Apply them directly as part of this skill.
+
 ### Step 6: Clear Active Project Pointer
 
 Clear the active project pointer immediately. If the user is completing a project, clearing the pointer is implicit — no confirmation needed.
diff --git a/.oat/repo/reference/backlog/index.md b/.oat/repo/reference/backlog/index.md
index 157abb9f0..25f0a3c96 100644
--- a/.oat/repo/reference/backlog/index.md
+++ b/.oat/repo/reference/backlog/index.md
@@ -5,7 +5,7 @@
 ## Curated Overview
 
 - `bl-42f9` tracks the only in-progress backlog item and is currently being delivered through the active `local-project-management` project.
-- Inbox work is concentrated on workflow operations: optional S3 archival for project completion and a Jira-oriented backlog refinement flow.
+- Inbox work is concentrated on workflow operations: project-completion hardening (`bl-0ace`, `bl-ea64`) and a Jira-oriented backlog refinement flow.
 - Planned follow-on investments cluster around provider ergonomics (`bl-cbdd`), review collaboration (`bl-9fb8`), dependency analysis (`bl-3327`), and ideas-to-project promotion (`bl-b3f7`).
 - Longer-horizon backlog work now includes explicit entries for freshness hardening (`bl-f9bd`) and memory/provider-enhancement work (`bl-71a1`).
 
@@ -18,6 +18,7 @@
 | bl-b3f7 | Add idea promotion and auto-discovery flow to oat-project-new                                   | open        | medium   | feature    | L        |
 | bl-9fb8 | Add PR review follow-on skill set (provide-remote, respond-remote, summarize-remote)            | open        | medium   | feature    | L        |
 | bl-ff5d | Backlog Refinement Flow (Jira ticket generation)                                                | open        | medium   | feature    | L        |
+| bl-0ace | Move oat-project-complete state mutations into a CLI helper                                     | open        | medium   | feature    | M        |
 | bl-cbdd | Optional Codex prompt-wrapper generation for synced OAT skills                                  | open        | medium   | feature    | M        |
 | bl-ea64 | Optional S3 archival in oat-project-complete workflow                                           | open        | medium   | feature    | L        |
 | bl-f9bd | Staleness + knowledge drift upgrades                                                            | open        | medium   | feature    | L        |
diff --git a/.oat/repo/reference/backlog/items/project-complete-cli-helper.md b/.oat/repo/reference/backlog/items/project-complete-cli-helper.md
new file mode 100644
index 000000000..8bdc5dccd
--- /dev/null
+++ b/.oat/repo/reference/backlog/items/project-complete-cli-helper.md
@@ -0,0 +1,26 @@
+---
+id: bl-0ace
+title: 'Move oat-project-complete state mutations into a CLI helper'
+status: open
+priority: medium
+scope: feature
+scope_estimate: M
+labels: ['workflow', 'cli']
+assignee: null
+created: '2026-03-21T00:28:34Z'
+updated: '2026-03-21T00:28:34Z'
+associated_issues: []
+oat_template: true
+oat_template_name: backlog-item
+---
+
+## Description
+
+`oat-project-complete` currently has to encode the exact `state.md` completion mutations in the skill body, including markdown body updates that are easy to drift from the canonical project state shape. The completion flow should move those state mutations into a CLI-owned helper so the skill can delegate to one implementation instead of carrying formatting rules and inferred conventions.
+
+## Acceptance Criteria
+
+- A CLI-owned helper or command updates project completion state in the canonical shape, including both frontmatter and markdown body mutations.
+- `oat-project-complete` delegates the state mutation work to the CLI helper instead of hardcoding the completion-state formatting contract.
+- Completing a project no longer requires checking archived project state files to infer the expected output shape.
+- Tests cover the resulting completion-state format and protect against drift between the CLI behavior and the skill guidance.