feat(unic-archon-dlc): complete plugin — all 16 slices (v0.1.0)

AGENTS.md

@@ -13,7 +13,8 @@ apps/
 ├── claude-code/              # Claude Code plugins — one dir per plugin
 │   ├── pr-review/
 │   ├── auto-format/
-│   └── unic-confluence/
+│   ├── unic-confluence/
+│   └── unic-archon-dlc/
 └── copilot/                  # GitHub Copilot plugins (future)
 packages/
 ├── biome-config/             # @unic/biome-config

CONTEXT-MAP.md

@@ -9,10 +9,12 @@
 - [auto-format](./apps/claude-code/auto-format/CONTEXT.md) — formatting automation hook for Claude Code
 - [pr-review](./apps/claude-code/pr-review/CONTEXT.md) — PR review command targeting Azure DevOps
 - [unic-confluence](./apps/claude-code/unic-confluence/CONTEXT.md) — Markdown-to-Confluence publishing command
+- [unic-archon-dlc](./apps/claude-code/unic-archon-dlc/CONTEXT.md) — Archon-powered AI development lifecycle DLC
 
 ## Relationships
 
-- All three Plugin contexts share the vocabulary defined in the monorepo context
-- **auto-format** and **pr-review** are Claude Code Plugins with no runtime dependencies on each other
+- All Plugin contexts share the vocabulary defined in the monorepo context
+- **auto-format**, **pr-review**, and **unic-archon-dlc** are Claude Code Plugins with no runtime dependencies on each other
 - **unic-confluence** can be installed as a git dependency for use outside Claude Code.
 - **pr-review** has a soft dependency on the `pr-review-toolkit` plugin from `anthropics/claude-plugins-official`
+- **unic-archon-dlc** requires the Archon workflow engine (version ≥ 0.10) in the target project; it has no runtime dependencies on any other plugin in this repo

README.md

@@ -4,11 +4,12 @@ A monorepo of AI agent plugins developed at Unic. Currently hosts Claude Code pl
 
 ## Plugins
 
-| Plugin                                                 | Agent       | Description                            |
-| ------------------------------------------------------ | ----------- | -------------------------------------- |
-| [`pr-review`](apps/claude-code/pr-review/)             | Claude Code | Review Azure DevOps pull requests      |
-| [`auto-format`](apps/claude-code/auto-format/)         | Claude Code | Auto-format and lint files after edits |
-| [`unic-confluence`](apps/claude-code/unic-confluence/) | Claude Code | Publish Markdown files to Confluence   |
+| Plugin                                                 | Agent       | Description                                                                              |
+| ------------------------------------------------------ | ----------- | ---------------------------------------------------------------------------------------- |
+| [`pr-review`](apps/claude-code/pr-review/)             | Claude Code | Review Azure DevOps pull requests                                                        |
+| [`auto-format`](apps/claude-code/auto-format/)         | Claude Code | Auto-format and lint files after edits                                                   |
+| [`unic-confluence`](apps/claude-code/unic-confluence/) | Claude Code | Publish Markdown files to Confluence                                                     |
+| [`unic-archon-dlc`](apps/claude-code/unic-archon-dlc/) | Claude Code | Archon-powered AI development lifecycle (explore → plan → build → qa → cleanup → triage) |
 
 ## Installing plugins (Claude Code)
 
@@ -24,6 +25,7 @@ Then install individual plugins:
 /plugin install pr-review@unic-agent-plugins
 /plugin install auto-format@unic-agent-plugins
 /plugin install unic-confluence@unic-agent-plugins
+/plugin install unic-archon-dlc@unic-agent-plugins
 ```
 
 ## Development

apps/claude-code/pr-review/tests/notices.test.mjs

@@ -131,7 +131,7 @@ describe('formatTrailer', () => {
 describe('mergeNotices', () => {
 	it('mergeNotices tolerates null and undefined sources', () => {
 		const n = createNotice('info', 'doc-context', 'test')
-		// @ts-ignore — intentional test of runtime tolerance for null/undefined
+		// @ts-expect-error — intentional test of runtime tolerance for null/undefined
 		const result = mergeNotices(null, [n], undefined)
 		assert.equal(result.length, 1)
 		assert.equal(result[0].kind, 'doc-context')

apps/claude-code/unic-archon-dlc/.archon/commands/unic-dlc-build.md

@@ -0,0 +1,59 @@
+# /unic-dlc-build
+
+Execute the TDD build workflow for a planning session, enforcing red → green per issue.
+
+## Usage
+
+```
+/unic-dlc-build <slug>
+```
+
+Where `<slug>` is the session identifier used when you ran `/unic-dlc-plan`. The generated
+`.archon/workflows/build-<slug>.yaml` must already exist (produced by the `yaml-gen` node in plan).
+
+## What this command does
+
+1. **Slopcheck gate** — before any implementation begins, scans `package.json` (and other
+   manifest files) for packages introduced since the last commit. Each new package is checked
+   against the npm registry. Packages that fail the check are flagged `[ASSUMED]` and require
+   explicit human approval before the build can continue.
+
+   Registry check strategy (in order of preference):
+
+   - Python `slopcheck` tool (GSD's slopsquatting gate) if available on `PATH`
+   - npm registry HEAD request fallback
+   - If neither is available: all new packages are treated as `[ASSUMED]` (strict default)
+
+   To bypass slopcheck for known-safe cases: `SLOPCHECK_BYPASS=1 /unic-dlc-build <slug>`
+
+2. **Generated build workflow** — executes `.archon/workflows/build-<slug>.yaml` which was
+   produced by the `yaml-gen` node in `/unic-dlc-plan`. The generated workflow:
+   - Issues a `code-red` node per issue: writes FAILING acceptance tests
+   - Issues a `code-green` node per issue: writes minimum implementation to pass those tests
+   - Enforces `code-red` before `code-green` within each issue via `depends_on` edges
+   - Runs independent issues' `code-red` (and `code-green`) phases in parallel
+
+## Prerequisites
+
+- `/unic-dlc-plan <slug>` must have been run and the plan PR approved
+- `.archon/workflows/build-<slug>.yaml` must exist
+- `.archon/unic-dlc.config.json` must be present (created by the install hook)
+
+## TDD contract
+
+Every issue in the build goes through:
+
+```
+RED:   code-red-<id>   → write failing acceptance tests
+GREEN: code-green-<id> → write minimum implementation to pass those tests
+```
+
+No `code-green` node may run before its corresponding `code-red` node completes.
+Independent issues run their `code-red` and `code-green` phases in parallel,
+giving the fastest possible end-to-end build time.
+
+## Runs
+
+```
+archon run .archon/workflows/build.yaml --input slug=<slug>
+```

apps/claude-code/unic-archon-dlc/.archon/commands/unic-dlc-cleanup.md

@@ -0,0 +1,60 @@
+# /unic-dlc-cleanup
+
+Post-merge cleanup for a planning session: architecture review, ADR consolidation, and a
+triage pass to refresh project state.
+
+## Usage
+
+```
+/unic-dlc-cleanup <slug>
+```
+
+Where `<slug>` is the session identifier used throughout the plan → build → qa cycle.
+
+## What this command does
+
+1. **`arch-review` node** — reads `docs/workflow/<slug>/PRD.md` (intent) and
+   `docs/workflow/<slug>/report.md` (technical outcome) alongside the changed code.
+   Detects three categories of drift:
+
+   - **Technical drift**: too-shallow modules, tight coupling, leaky abstractions.
+   - **Intent drift**: delivered behaviour that diverges from the PRD; silently dropped
+     acceptance criteria; scope creep added during build.
+   - **Deepening opportunities**: modules that could hide more complexity behind their
+     current interface.
+
+   Output: `docs/workflow/<slug>/arch-review.md`
+
+2. **`adr-consolidation` interactive node** — presents each proposed ADR individually for
+   human approval. Sources:
+
+   - "Decisions Made" section of `report.md`
+   - "Accept as ADR" items from `arch-review.md`
+
+   Each ADR is shown with Context, Decision, and Consequences. The user accepts (A),
+   rejects (R), or edits (E) each candidate. Only accepted ADRs are written to `docs/adr/`.
+
+3. **`run-triage` node** — invokes the shared `.archon/workflows/triage.yaml` directly via
+   `archon run`. No triage logic is duplicated in the cleanup workflow. This produces
+   `HANDOFF.md` and updates `docs/workflow/ROADMAP.md` exactly once per cleanup run.
+
+## Prerequisites
+
+- The build and QA cycles for `<slug>` must be complete (build PR merged, QA approved)
+- `docs/workflow/<slug>/PRD.md` and `docs/workflow/<slug>/report.md` must exist
+- `.archon/unic-dlc.config.json` must be present
+
+## Outputs
+
+| File                                  | Description                                     |
+| ------------------------------------- | ----------------------------------------------- |
+| `docs/workflow/<slug>/arch-review.md` | Architecture review with drift findings         |
+| `docs/adr/NNNN-*.md`                  | Accepted ADRs (one file per accepted candidate) |
+| `HANDOFF.md`                          | Updated handoff snapshot (from triage)          |
+| `docs/workflow/ROADMAP.md`            | Updated project phase (from triage)             |
+
+## Runs
+
+```
+archon run .archon/workflows/cleanup.yaml --input slug=<slug>
+```

apps/claude-code/unic-archon-dlc/.archon/commands/unic-dlc-explore.md

@@ -0,0 +1,54 @@
+---
+description: Run the unic-archon-dlc explore workflow — parallel research across stack, features, architecture, and pitfalls, then synthesize into docs/workflow/<slug>/findings.md
+---
+
+# /unic-dlc-explore
+
+Runs the `explore` workflow: four parallel research agents investigate the project from different angles, then a synthesize node combines their findings into a single `findings.md` document.
+
+## When to use
+
+- At the start of a new feature or investigation to build a shared mental model.
+- When onboarding to an unfamiliar project or module.
+- Before writing a spec, to surface pitfalls and architecture constraints early.
+- Any time you want a structured snapshot of what the project is, what it does, and where the risks are.
+
+## What it produces
+
+- **`docs/workflow/<slug>/findings.md`** — five sections:
+  - **Stack** — runtime, package manager, toolchain
+  - **Features** — shipped capabilities, in-progress work, planned features
+  - **Architecture** — directory structure, design patterns, ADR decisions, cross-platform constraints
+  - **Pitfalls** — TODOs, untested modules, CI issues, HANDOFF.md blockers
+  - **Integrated Brief** — 3-5 sentence synthesis with the highest-impact next step
+
+## Usage
+
+```sh
+archon run .archon/workflows/explore.yaml --input slug=<slug>
+```
+
+Or invoke from Claude Code:
+
+```
+/unic-dlc-explore <slug>
+```
+
+Replace `<slug>` with a short identifier for this exploration (e.g. `auth-refactor`, `v2-planning`).
+
+## Workflow structure
+
+```
+research-stack  ──┐
+research-features ─┤
+                   ├──▶  synthesize  ──▶  findings.md
+research-architecture ─┤
+research-pitfalls ──┘
+```
+
+All four research nodes are independent and run in parallel. The `synthesize` node depends on all four and writes the final output.
+
+## Inspiration
+
+- Parallel research pattern from the Archon workflow specification.
+- This plugin's `lib/findings-writer.mjs` handles idempotent directory and file creation.

apps/claude-code/unic-archon-dlc/.archon/commands/unic-dlc-plan.md

@@ -0,0 +1,61 @@
+---
+description: Run the unic-archon-dlc plan workflow — adversarial spec interview, PRD synthesis, and human PR gate
+---
+
+# /unic-dlc-plan
+
+Runs the `plan` workflow: loads project context and prior research, runs an adversarial interview to surface requirements and decisions, synthesises the transcript into a structured PRD, and opens a PR for human review before proceeding.
+
+## When to use
+
+- After `/unic-dlc-explore` to turn research findings into a formal PRD.
+- When starting a new feature and you want to stress-test assumptions before writing specs.
+- Any time you need a structured `PRD.md` that captures problem, solution, stories, decisions, and scope.
+
+## What it produces
+
+- **`docs/workflow/<slug>/PRD.md`** — seven sections: Problem Statement, Solution, User Stories, Implementation Decisions, Testing Decisions, Out of Scope, Further Notes.
+- **`docs/adr/NNNN-<slug>.md`** — one or more ADR files for non-obvious decisions surfaced during the interview (written live, confirmed by user).
+- **PR** targeting `develop` — pauses until approved. Rejection returns control to the adversarial interview for refinement.
+
+## Usage
+
+```sh
+archon run .archon/workflows/plan.yaml --input slug=<slug>
+```
+
+Or invoke from Claude Code:
+
+```
+/unic-dlc-plan <slug>
+```
+
+Replace `<slug>` with a short identifier for this planning session (e.g. `auth-refactor`, `v2-planning`).
+
+## Options
+
+Set `workflow.discuss_mode` in `.archon/unic-dlc.config.json` to control the interview style:
+
+| Value                 | Behaviour                                                                |
+| --------------------- | ------------------------------------------------------------------------ |
+| `interview` (default) | One focused, adversarial question per turn; probes deeply                |
+| `assumptions`         | Surfaces all implicit assumptions upfront, then confirms or refutes each |
+
+## Workflow structure
+
+```
+load-context ──▶ specs (loop) ──▶ to-prd ──▶ prd-gate (interactive)
+                     ▲                              │
+                     └──────── rejected ────────────┘
+```
+
+- `load-context` reads CONTEXT.md, CONTEXT-MAP.md, all ADRs, and findings.md (if present).
+- `specs` runs the adversarial interview; writes ADRs live for confirmed decisions.
+- `to-prd` synthesises the interview transcript into PRD.md.
+- `prd-gate` validates all 7 sections, opens a PR, and waits for human approval.
+
+## Inspiration
+
+- The `grill-with-docs` skill — adversarial interview pattern against the domain model.
+- The `to-prd` skill — structured PRD synthesis from conversation context.
+- Archon PR-gate pattern for human-in-the-loop workflow checkpoints.

apps/claude-code/unic-archon-dlc/.archon/commands/unic-dlc-qa.md

@@ -0,0 +1,78 @@
+---
+description: Run the unic-archon-dlc QA workflow — e2e tests, coverage gate, UAT checklist, and merge
+---
+
+# /unic-dlc-qa
+
+Runs the `qa` workflow: executes end-to-end tests, enforces the coverage threshold, walks through
+a UAT checklist derived from the PRD's acceptance criteria, and merges the PR once the human approves.
+
+## When to use
+
+- After `/unic-dlc-build <slug>` is complete and the build PR has been reviewed and approved.
+- When you want a structured QA gate before merging a feature branch.
+- Any time you need to confirm that acceptance criteria are met before shipping.
+
+## What it produces
+
+- **e2e results** — pass/fail output from the command configured in `e2e_command`.
+- **Coverage report** — pass/fail against the `coverage_threshold` set in `.archon/unic-dlc.config.json`.
+- **UAT checklist** — numbered acceptance criteria from `docs/workflow/<slug>/PRD.md`, presented alongside build coverage evidence.
+- **Merged PR** — once UAT is approved, the PR is merged via the configured tracker CLI and the feature branch is cleaned up (Gitflow only).
+
+## Usage
+
+```sh
+archon run .archon/workflows/qa.yaml --input slug=<slug>
+```
+
+Or invoke from Claude Code:
+
+```
+/unic-dlc-qa <slug>
+```
+
+Replace `<slug>` with the same identifier used in `/unic-dlc-plan` and `/unic-dlc-build`.
+
+## Prerequisites
+
+- `/unic-dlc-build <slug>` must have been run and the build PR approved.
+- `.archon/unic-dlc.config.json` must be present (created by the install hook).
+- `e2e_command` must be set in the config. If not, run `archon install --reconfigure` to set it.
+- The current branch must have an open PR targeting `develop` (for the merge step).
+
+## Workflow structure
+
+```
+e2e  ──▶  coverage-gate  ──▶  uat-gate (interactive)  ──▶  merge
+```
+
+- `e2e` — reads `e2e_command` from config; fails fast with a helpful message if it is not set.
+- `coverage-gate` — runs `pnpm test --coverage`; parses the output to compare against `coverage_threshold`. Skipped if no threshold is configured.
+- `uat-gate` — presents the numbered UAT checklist; waits for APPROVE or REJECT from the human.
+- `merge` — merges the PR via the tracker CLI (gh / az / manual instructions for jira and local-markdown); deletes the feature branch on Gitflow.
+
+## Configuration reference
+
+All settings are read from `.archon/unic-dlc.config.json`:
+
+| Field                | Type   | Default     | Description                                                              |
+| -------------------- | ------ | ----------- | ------------------------------------------------------------------------ |
+| `e2e_command`        | string | —           | Shell command to run e2e tests (e.g. `"pnpm test:e2e"`)                  |
+| `coverage_threshold` | number | —           | Minimum coverage % required (e.g. `80`). Omit to skip the gate.          |
+| `tracker`            | string | `"github"`  | Issue tracker: `github`, `ado`, `jira`, `local-markdown`                 |
+| `branching`          | string | `"gitflow"` | Branch strategy: `gitflow` (delete feature branch) or `github-flow`      |
+| `pr_strategy`        | string | `"squash"`  | GitHub merge style: `squash` or `merge` (used for `github` tracker only) |
+
+## UAT interaction
+
+The `uat-gate` node pauses and asks for your decision:
+
+- Type **`APPROVE`** to proceed to merge.
+- Type **`REJECT AC-N`** (e.g. `REJECT AC-3`) to flag a failing criterion. The workflow halts and you are returned to address the issue before re-running.
+
+## Runs
+
+```
+archon run .archon/workflows/qa.yaml --input slug=<slug>
+```