@wazir-dev/cli 1.0.0 → 1.1.0

package/skills/wazir/SKILL.md

@@ -61,16 +61,48 @@ Run `which wazir` to check if the CLI is installed.
 >
 > **How would you like to install it?**
 >
-> 1. **npm** (Recommended) — `npm install -g wazir`
+> 1. **npm** (Recommended) — `npm install -g @wazir-dev/cli`
 > 2. **Local link** — `npm link` from the Wazir project root
-> 3. **Skip** — Continue without the CLI (some features will be unavailable)
 
-If the user picks 1, run `npm install -g wazir` and verify with `wazir --version`.
+If the user picks 1, run `npm install -g @wazir-dev/cli` and verify with `wazir --version`.
 If the user picks 2, run `npm link` from the project root and verify.
-If the user picks 3, warn that `wazir capture`, `wazir validate`, and `wazir index` commands will not work, then continue.
+
+The CLI is **required** — the pipeline uses `wazir capture`, `wazir validate`, `wazir index`, and `wazir doctor` throughout execution. There is no skip option.
 
 **If installed**, run `wazir doctor --json` to verify repo health.
 
+If doctor reports unhealthy:
+> **Repo health check failed:** [details from doctor output]
+> Fix issues before running the pipeline.
+
+Stop. Do NOT continue the pipeline until the health check passes.
+
+### Branch Check
+
+Run `wazir validate branches` to check the current git branch.
+
+- If on `main` or `develop`:
+  > You're on **[branch]**. The pipeline requires a feature branch.
+  >
+  > 1. **Create feat/<slug>** (Recommended) — branch from current
+  > 2. **Continue on [branch]** — not recommended for feature/refactor work
+
+  Wait for the user to answer before continuing.
+
+- If branch name is invalid (not `feat/`, `fix/`, `chore/`, etc.): warn but continue.
+
+### Index Check
+
+```bash
+INDEX_STATS=$(wazir index stats --json 2>/dev/null)
+FILE_COUNT=$(echo "$INDEX_STATS" | jq -r '.file_count // 0')
+if [ "$FILE_COUNT" -eq 0 ]; then
+  wazir index build && wazir index summarize --tier all
+else
+  wazir index refresh
+fi
+```
+
 ### Pipeline Init Check
 
 Check if `.wazir/state/config.json` exists.
@@ -89,6 +121,12 @@ ln -sfn run-YYYYMMDD-HHMMSS .wazir/runs/latest
 
 If a previous completed run exists (check for a `completed_at` field in the previous `latest` run's `run-config.yaml`), record its `run_id` as `parent_run_id` in the new run's config.
 
+After creating the run directory, initialize event capture:
+
+```bash
+wazir capture init --run <run-id> --phase clarify --status starting
+```
+
 ## Step 3: Pre-Flight Configuration
 
 Build the run configuration. Skip questions that were answered via inline modifiers.
@@ -150,11 +188,21 @@ parallel_backend: none                 # none | claude_teams (future: subagents,
 
 # Phase policy (system-decided, not user-facing)
 phase_policy:
-  discover: { enabled: true, reason: "feature intent requires research" }
-  design: { enabled: true, reason: "new UI component" }
-  spec-challenge: { enabled: true, passes: 2, reason: "standard depth" }
-  author: { enabled: false, reason: "no i18n or seed data needed" }
-  plan-review: { enabled: true, passes: 1 }
+  discover:       { enabled: true, loop_cap: 10 }
+  clarify:        { enabled: true, loop_cap: 10 }
+  specify:        { enabled: true, loop_cap: 10 }
+  spec-challenge: { enabled: true, loop_cap: 10 }
+  author:         { enabled: false, loop_cap: 10 }
+  design:         { enabled: true, loop_cap: 10 }
+  design-review:  { enabled: true, loop_cap: 10 }
+  plan:           { enabled: true, loop_cap: 10 }
+  plan-review:    { enabled: true, loop_cap: 10 }
+  execute:        { enabled: true, loop_cap: 10 }
+  verify:         { enabled: true, loop_cap: 5 }
+  review:         { enabled: true, loop_cap: 10 }
+  learn:          { enabled: false, loop_cap: 5 }
+  prepare_next:   { enabled: false, loop_cap: 5 }
+  run_audit:      { enabled: false, loop_cap: 10 }
 
 # Research
 research_topics: []                    # populated by researcher phase
@@ -176,15 +224,15 @@ Map intent + depth to applicable phases. The system decides — the user does NO
 |-------|--------|-------|
 | **Core** (always run) | `clarify`, `verify`, `review` | Never skipped |
 | **Adaptive** (run when evidence says so) | `discover`, `design`, `author`, `specify` | Skipped for bugfix/docs/spike at quick depth |
-| **Scale** (intensity varies) | `spec-challenge`, `plan-review`, `design-review` | Single-pass at quick, multi-pass at deep |
+| **Scale** (intensity varies) | `spec-challenge`, `plan-review`, `design-review` | Loop cap controls iteration depth |
 
 Log skip decisions to the run's `run-config.yaml` with reasons:
 
 ```yaml
 phase_policy:
-  discover: { enabled: true }
-  design: { enabled: false, reason: "bugfix intent — no design needed" }
-  spec-challenge: { enabled: true, passes: 1, reason: "quick depth" }
+  discover:       { enabled: true, loop_cap: 10 }
+  design:         { enabled: false, loop_cap: 10, reason: "bugfix intent — no design needed" }
+  spec-challenge: { enabled: true, loop_cap: 10 }
 ```
 
 ### Confidence Gate
@@ -192,7 +240,7 @@ phase_policy:
 After building the run config, evaluate confidence:
 
 - **High confidence** (clear intent, depth set, no ambiguity) — show a one-line summary and proceed:
-  > **Running: standard depth, feature, sequential. 11 of 14 phases. Proceeding...**
+  > **Running: standard depth, feature, sequential. 11 of 15 phases. Proceeding...**
 
 - **Low confidence** (ambiguous intent, unclear scope) — show the full plan and ask:
   > **Here's the run plan:**
@@ -205,11 +253,13 @@ After building the run config, evaluate confidence:
   > 1. **Yes, proceed** (Recommended)
   > 2. **No, let me adjust**
 
-## Step 4: Run Clarifier
+## Step 4: Run Pipeline Phases
+
+The full pipeline runs these phases in order. Each phase produces an artifact that must pass its review loop before flowing to the next phase. Review mode is always passed explicitly (`--mode`) -- no auto-detection.
 
-### Source Capture
+### 4a: Source Capture
 
-Before invoking the clarifier, instruct the researcher to capture all referenced sources locally:
+Before invoking the clarifier, capture all referenced sources locally:
 
 - Fetch all URLs referenced in `.wazir/input/` briefing files
 - Save fetched content to `.wazir/runs/<run-id>/sources/`
@@ -238,46 +288,194 @@ Before invoking the clarifier, instruct the researcher to capture all referenced
 
 Research briefs produced by the researcher must reference local paths (`sources/src-001-...`) instead of live URLs. The original URL is preserved in the manifest for provenance. Failures are recorded explicitly — never silently skipped.
 
-### Clarifier Invocation
+### 4b: Clarify (clarifier role)
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase clarify --status in_progress
+```
 
-Invoke the `clarifier` skill.
+Invoke the clarifier skill for Phase 1A.
+Produces clarification artifact.
+Review: clarification-review loop (`--mode clarification-review`, spec/clarification dimensions).
+Pass count: quick=3, standard=5, deep=7. No extension.
+Checkpoint: user approves clarification.
 
-This runs the full Phase 0 + Phase 1 pipeline:
-- Phase 0: Research (autonomous — skipped if depth=quick and intent=bugfix)
-- Phase 1A: Clarify (autonomous)
-- Phase 1A+: Spec Harden (passes determined by depth)
-- Phase 1B: Brainstorm (interactive — **will pause for user approval**. If `team_mode: parallel`, uses structured dialogue with Free Thinker + Grounder + Synthesizer agents)
-- Phase 1C: Plan (task generation)
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase clarify --status completed
+```
 
-**Resume detection:** If `.wazir/runs/latest/clarified/` already has task specs and an execution plan, ask:
+### 4c: Research (researcher role via discover workflow)
 
-> **Clarification was already completed. What would you like to do?**
->
-> 1. **Skip to execution** (Recommended) — Use existing task specs
-> 2. **Re-run clarifier** — Start fresh
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase discover --status in_progress
+```
+
+Clarifier delegates to discover workflow (researcher role).
+Produces research artifact.
+Review: research-review loop (`--mode research-review`, research dimensions).
+Pass count: quick=3, standard=5, deep=7. No extension.
+Skip condition: depth=quick AND intent=bugfix.
+
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase discover --status completed
+```
+
+### 4d: Specify (specifier role)
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase specify --status in_progress
+```
+
+Delegate to specify workflow.
+Specifier produces measurable spec from clarification + research.
+Review: spec-challenge loop (`--mode spec-challenge`, spec/clarification dimensions).
+Pass count: quick=3, standard=5, deep=7. No extension.
+Checkpoint: user approves spec.
+
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase specify --status completed
+```
+
+### 4d.5: Author (content-author role) [ADAPTIVE]
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase author --status in_progress
+```
+
+Enabled when `phase_policy.author.enabled = true` (default: false).
+Content-author writes non-code content artifacts.
+Approval gate: human approval required (not a review loop).
+Skip condition: disabled by default. Enable for content-heavy projects.
+
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase author --status completed
+```
+
+### 4e: Brainstorm (designer role)
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase design --status in_progress
+```
 
-## Step 5: Run Executor
+Invoke brainstorming skill for Phase 1B.
+Interactive -- pauses for user approval of design concept.
+After user approval: design-review loop (`--mode design-review`,
+canonical design-review dimensions: spec coverage, design-spec consistency,
+accessibility, visual consistency, exported-code fidelity).
+Pass count: quick=3, standard=5, deep=7. No extension.
+Skip condition: intent=bugfix/docs.
 
-Invoke the `executor` skill.
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase design --status completed
+```
+
+### 4f: Plan (planner role via wz:writing-plans)
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase plan --status in_progress
+```
+
+Delegate to `wz:writing-plans`.
+Planner produces execution plan and task specs.
+Review: plan-review loop (`--mode plan-review`, plan dimensions).
+Pass count: quick=3, standard=5, deep=7. No extension.
+Checkpoint: user approves plan.
 
-This runs Phase 2: autonomous execution with the composition engine, TDD, and quality gates.
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase plan --status completed
+```
+
+### 4g: Execute (executor role)
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase execute --status in_progress
+```
+
+**Pre-execution gate** — run before the first task:
+
+```bash
+wazir validate manifest && wazir validate hooks
+# If either fails, stop and report the failure. Do NOT proceed to task execution.
+```
+
+Invoke executor skill for Phase 2.
+Per-task review: task-review loop (`--mode task-review --task-id <NNN>`,
+5 task-execution dimensions) before each commit.
+Review logs: `execute-task-<NNN>-review-pass-<N>.md`
+Cap tracking: `wazir capture loop-check --task-id <NNN>`
+Codex error handling: non-zero exit -> codex-unavailable, self-review only.
+NOTE: per-task review is NOT the final review.
 
 If `team_mode: parallel` in run-config, the executor spawns Agent Teams for independent tasks. Otherwise, tasks run sequentially.
 
-**Resume detection:** If `.wazir/runs/latest/artifacts/` has completed artifacts, ask:
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase execute --status completed
+```
+
+### 4h: Verify (verifier role)
 
-> **Some tasks are already completed. What would you like to do?**
->
-> 1. **Resume** (Recommended) — Continue from where it left off
-> 2. **Start fresh** — Re-run all tasks from scratch
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase verify --status in_progress
+```
+
+Deterministic verification of execution claims.
+Not a review loop -- produces proof, not findings.
 
-## Step 6: Run Reviewer
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase verify --status completed
+```
+
+### 4i: Final Review (reviewer role in final mode)
+
+```bash
+wazir capture event --run <run-id> --event phase_enter --phase review --status in_progress
+```
+
+Invoke reviewer skill with `--mode final`.
+7-dimension scored review (correctness, completeness, wiring, verification,
+drift, quality, documentation). Score 0-70.
+This IS the scored final review gate.
+
+```bash
+wazir capture event --run <run-id> --event phase_exit --phase review --status completed
+```
+
+### 4j: Learn (learner role) [ADAPTIVE]
+
+Enabled when `phase_policy.learn.enabled = true` (default: false).
+Extract durable learnings from the completed run.
+No review loop. Learnings require explicit scope tags.
+Skip condition: disabled by default. Enable for retrospective runs.
+
+### 4k: Prepare Next (planner role) [ADAPTIVE]
 
-Invoke the `reviewer` skill.
+Enabled when `phase_policy.prepare_next.enabled = true` (default: false).
+Prepare context and handoff for the next run.
+No review loop. No implicit carry-forward of unapproved learnings.
+Skip condition: disabled by default.
 
-This runs Phase 3: final scoring across 7 dimensions, produces a verdict.
+`run_audit` is NOT part of the pipeline flow -- it is an on-demand standalone phase invoked separately.
 
-## Step 7: Present Results
+### Resume Detection
+
+If the run has partial progress, detect the latest completed phase and resume:
+
+- If clarification exists but no spec: resume at 4d (specify)
+- If spec exists but no design: resume at 4e (brainstorm)
+- If design exists but no plan: resume at 4f (plan)
+- If plan exists but no task artifacts: resume at 4g (execute)
+- If task artifacts exist but no verification: resume at 4h (verify)
+- If verification exists: resume at 4i (final review)
+
+Present resume options:
+
+> **Previous progress detected (completed through [phase]).**
+>
+> **What would you like to do?**
+> 1. **Resume from [next phase]** (Recommended)
+> 2. **Start fresh** — Re-run all phases from scratch
+
+## Step 5: Present Results
 
 After the reviewer completes, present the verdict and offer next steps with numbered options:
 
@@ -322,6 +520,15 @@ After the reviewer completes, present the verdict and offer next steps with numb
 >
 > Something fundamental went wrong. Review the findings above and decide how to proceed.
 
+### Run Summary
+
+After presenting results (regardless of verdict), capture the run summary:
+
+```bash
+wazir capture summary --run <run-id>
+wazir status --run <run-id> --json
+```
+
 ## Error Handling
 
 If any phase fails or the user cancels:
@@ -364,7 +571,7 @@ After the audit completes:
 > 2. **Generate a fix plan** — turn findings into implementation tasks
 > 3. **Run the pipeline on the fix plan** — generate plan, then execute and review fixes
 
-If the user picks option 3, save the findings as the briefing and run the normal pipeline (Steps 3-7) with intent = `bugfix`.
+If the user picks option 3, save the findings as the briefing and run the normal pipeline (Steps 3-5) with intent = `bugfix`.
 
 ---
 

package/skills/writing-plans/SKILL.md

@@ -11,9 +11,12 @@ Inputs:
 - current repo state
 - relevant research findings
 
-Output:
+Output path:
 
-- one implementation plan in `docs/plans/YYYY-MM-DD-<topic>-implementation.md`
+- **Inside a pipeline run** (`.wazir/runs/latest/` exists): write to `.wazir/runs/latest/clarified/execution-plan.md` and task specs to `.wazir/runs/latest/tasks/task-NNN/spec.md`
+- **Standalone** (no active run): write to `docs/plans/YYYY-MM-DD-<topic>-implementation.md`
+
+To detect: check if `.wazir/runs/latest/clarified/` exists. If yes, use run paths.
 
 The plan must include:
 
@@ -25,6 +28,30 @@ The plan must include:
 
 Rules:
 
-- do not write repo-local task files outside the plan directory
-- do not rely on retired `run-*` workflow wrappers
+- do not write implementation code during planning
 - make the plan detailed enough that another weak model can execute it without inventing missing steps
+- each task spec must have testable acceptance criteria, not vague descriptions
+
+## Plan Review Loop
+
+After writing the plan, the reviewer role runs the plan-review loop with `--mode plan-review` using plan dimensions (see `workflows/plan-review.md` and `docs/reference/review-loop-pattern.md`).
+
+The planner resolves findings from each pass. The loop runs for `pass_counts[depth]` passes (quick=3, standard=5, deep=7). No extension.
+
+For non-code artifacts (the plan itself), Codex review uses stdin pipe:
+
+```bash
+CODEX_MODEL=$(jq -r '.multi_tool.codex.model // empty' .wazir/state/config.json 2>/dev/null)
+CODEX_MODEL=${CODEX_MODEL:-gpt-5.4}
+cat <plan-path> | codex exec -c model="$CODEX_MODEL" "Review this implementation plan focusing on [dimension]..."
+```
+
+`codex review -c model="$CODEX_MODEL"` is used only for code artifacts, not plans.
+
+Codex error handling: if `codex` exits non-zero, log the error, mark the pass as `codex-unavailable`, and use self-review findings only. Never treat a Codex failure as a clean pass.
+
+Loop depth follows the project's depth config (quick/standard/deep).
+
+Standalone mode: if no `.wazir/runs/latest/` exists, artifacts go to `docs/plans/` and review logs go alongside (`docs/plans/YYYY-MM-DD-<topic>-review-pass-N.md`). Loop cap guard is not invoked in standalone mode.
+
+After the loop completes, present findings summary and wait for user approval before completing.

package/templates/examples/wazir-manifest.example.yaml

@@ -49,7 +49,7 @@ protected_paths:
   - input
   - exports/hosts
 prohibited_terms:
-  - agent-os
+  - legacy-name
 adapters:
   context_mode:
     enabled_by_default: false

package/tooling/src/capture/command.js

@@ -16,7 +16,9 @@ import {
   writeStatus,
   writeSummary,
 } from './store.js';
+import { readRunConfig, getPhaseLoopCap } from './run-config.js';
 import { readUsage, generateReport, initUsage, recordCaptureSavings, recordPhaseUsage } from './usage.js';
+import { evaluateLoopCapGuard } from '../guards/loop-cap-guard.js';
 
 function formatResult(payload, options = {}) {
   if (options.json) {
@@ -68,6 +70,7 @@ function resolveCaptureContext(parsed, context = {}) {
       'capture-path',
       'command',
       'exit-code',
+      'task-id',
     ],
   });
   const stateRoot = resolveStateRoot(projectRoot, manifest, {
@@ -346,6 +349,87 @@ function handleUsage(parsed, context = {}) {
   };
 }
 
+function handleLoopCheck(parsed, context = {}) {
+  const { stateRoot, options } = resolveCaptureContext(parsed, context);
+
+  requireOption(options, 'run', 'Usage: wazir capture loop-check --run <id> --phase <phase> --loop-count <n> [--task-id <id>] [--state-root <path>] [--json]');
+  requireOption(options, 'phase', 'Usage: wazir capture loop-check --run <id> --phase <phase> --loop-count <n> [--task-id <id>] [--state-root <path>] [--json]');
+  requireOption(options, 'loopCount', 'Usage: wazir capture loop-check --run <id> --phase <phase> --loop-count <n> [--task-id <id>] [--state-root <path>] [--json]');
+
+  const runPaths = getRunPaths(stateRoot, options.run);
+
+  // Standalone mode: if status.json doesn't exist, allow (exit 0)
+  if (!fs.existsSync(runPaths.statusPath)) {
+    const notice = 'loop-check: standalone mode (no status.json), allowing.\n';
+    return {
+      exitCode: 0,
+      stdout: options.json ? `${JSON.stringify({ allowed: true, reason: 'standalone mode' }, null, 2)}\n` : '',
+      stderr: options.json ? '' : notice,
+    };
+  }
+
+  // Record the event and update loop count in status.json
+  const status = readStatus(runPaths);
+  const loopCount = parsePositiveInteger(options.loopCount, '--loop-count');
+  const loopPhase = options.phase;
+  const loopKey = options.taskId ? `${loopPhase}:${options.taskId}` : loopPhase;
+
+  status.phase_loop_counts = {
+    ...(status.phase_loop_counts ?? {}),
+    [loopKey]: loopCount,
+  };
+
+  const event = createBaseEvent('loop_iteration', {
+    run_id: options.run,
+    phase: loopPhase,
+    status: status.status,
+    loop_count: loopCount,
+    loop_key: loopKey,
+  });
+
+  if (options.taskId) {
+    event.task_id = options.taskId;
+  }
+
+  status.updated_at = event.created_at;
+  status.last_event = 'loop_iteration';
+
+  appendEvent(runPaths, event);
+  writeStatus(runPaths, status);
+
+  // Read run-config for loop_cap
+  const runConfig = readRunConfig(runPaths);
+  const loopCap = getPhaseLoopCap(runConfig, loopPhase);
+
+  // Evaluate the guard using loopKey (task-scoped or phase-scoped).
+  // Cap is per-phase but counts are per-task — each task gets its own
+  // budget up to the phase cap. This is intentional: task-scoped tracking
+  // prevents parallel tasks from sharing a single counter.
+  const guardResult = evaluateLoopCapGuard({
+    run_id: options.run,
+    phase: loopKey,
+    state_root: stateRoot,
+    loop_cap: loopCap,
+  });
+
+  if (!guardResult.allowed) {
+    return {
+      exitCode: 43,
+      stderr: `${guardResult.reason}\n`,
+      stdout: options.json ? `${JSON.stringify(guardResult, null, 2)}\n` : '',
+    };
+  }
+
+  return formatResult({
+    run_id: options.run,
+    phase: loopPhase,
+    loop_key: loopKey,
+    loop_count: loopCount,
+    loop_cap: loopCap,
+    allowed: true,
+  }, { json: options.json });
+}
+
 export function runCaptureCommand(parsed, context = {}) {
   try {
     switch (parsed.subcommand) {
@@ -361,10 +445,12 @@ export function runCaptureCommand(parsed, context = {}) {
         return handleSummary(parsed, context);
       case 'usage':
         return handleUsage(parsed, context);
+      case 'loop-check':
+        return handleLoopCheck(parsed, context);
       default:
         return {
           exitCode: 1,
-          stderr: 'Usage: wazir capture <init|event|route|output|summary|usage> ...\n',
+          stderr: 'Usage: wazir capture <init|event|route|output|summary|usage|loop-check> ...\n',
         };
     }
   } catch (error) {

package/tooling/src/capture/run-config.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readYamlFile } from '../loaders.js';
+
+const DEFAULT_PHASE_POLICY = {
+  loop_cap: 10,
+  enabled: true,
+};
+
+export function readRunConfig(runPaths) {
+  const configPath = path.join(runPaths.runRoot, 'run-config.yaml');
+  if (!fs.existsSync(configPath)) {
+    return { phase_policy: {} };
+  }
+  return readYamlFile(configPath);
+}
+
+export function getPhaseLoopCap(runConfig, phase) {
+  const policy = runConfig?.phase_policy?.[phase] ?? DEFAULT_PHASE_POLICY;
+  return policy.loop_cap ?? DEFAULT_PHASE_POLICY.loop_cap;
+}

package/tooling/src/checks/brand-truth.js

@@ -7,17 +7,14 @@ const EXCLUDED_DOC_FILES = new Set([
 ]);
 
 const BRAND_PATTERNS = [
-  { label: 'Agent OS', regex: /\bAgent OS\b/g },
-  { label: 'agent-os', regex: /\bagent-os\b/g },
-  { label: 'Symphony', regex: /\bSymphony\b/g },
   { label: 'Wazir OS', regex: /\bWazir OS\b/g },
 ];
 
 function normalizeAllowedLegacyReferences(content) {
   return content
-    .replace(/archive\/legacy-agent-os\/[^\s)`]*/g, 'archive/<legacy>')
-    .replace(/archive\/v5\.1-agent-os-daemon\/[^\s)`]*/g, 'archive/<legacy>')
-    .replace(/migration\/v5\.1-agent-os-to-wazir\.md/g, 'migration/<legacy>');
+    .replace(/archive\/legacy-wazir\/[^\s)`]*/g, 'archive/<legacy>')
+    .replace(/archive\/v5\.1-wazir-daemon\/[^\s)`]*/g, 'archive/<legacy>')
+    .replace(/migration\/v5\.1-wazir-rename\.md/g, 'migration/<legacy>');
 }
 
 function walkMarkdownFiles(dirPath, files = []) {

package/tooling/src/checks/command-registry.js

@@ -33,4 +33,5 @@ export const SUPPORTED_COMMAND_SUBJECTS = new Set([
   'wazir capture output',
   'wazir capture summary',
   'wazir capture usage',
+  'wazir capture loop-check',
 ]);

package/tooling/src/checks/docs-truth.js

@@ -5,7 +5,7 @@ import { readJsonFile, readYamlFile } from '../loaders.js';
 import { validateAgainstSchema } from '../schema-validator.js';
 import { SUPPORTED_COMMAND_SUBJECTS } from './command-registry.js';
 
-const EXCLUDED_DOC_DIRS = new Set(['daemon', 'plans', 'research', 'audit']);
+const EXCLUDED_DOC_DIRS = new Set(['plans', 'research', 'audit']);
 
 function walkMarkdownFiles(dirPath, files = []) {
   for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {

package/tooling/src/checks/runtime-surface.js

@@ -9,13 +9,9 @@ const EXCLUDED_DOC_FILES = new Set([
 ]);
 
 const FORBIDDEN_TEXT_PATTERNS = [
-  { label: '.agent-os path', regex: /\.agent-os\//g },
   { label: 'tasks/input path', regex: /\btasks\/input\//g },
   { label: 'tasks/clarified path', regex: /\btasks\/clarified\//g },
   { label: 'legacy run wrapper', regex: /\/run-(clarifier|orchestrator|opus-reviewer)\b/g },
-  { label: 'legacy daemon binary', regex: /\bagent-os-(daemon|run|review|orchestrate)\b/g },
-  { label: 'legacy npx invocation', regex: /\bnpx agent-os-[a-z-]+\b/g },
-  { label: 'daemon workflow config', regex: /daemon\/WORKFLOW\.md/g },
 ];
 
 const FORBIDDEN_DEPENDENCIES = new Set(['express', 'fastify', 'koa', 'socket.io']);
@@ -93,9 +89,9 @@ function collectRuntimeSurfaceFiles(projectRoot) {
 
 function normalizeAllowedLegacyReferences(content) {
   return content
-    .replace(/archive\/legacy-agent-os\/[^\s)`]*/g, 'archive/<legacy>')
-    .replace(/archive\/v5\.1-agent-os-daemon\/[^\s)`]*/g, 'archive/<legacy>')
-    .replace(/migration\/v5\.1-agent-os-to-wazir\.md/g, 'migration/<legacy>');
+    .replace(/archive\/legacy-wazir\/[^\s)`]*/g, 'archive/<legacy>')
+    .replace(/archive\/v5\.1-wazir-daemon\/[^\s)`]*/g, 'archive/<legacy>')
+    .replace(/migration\/v5\.1-wazir-rename\.md/g, 'migration/<legacy>');
 }
 
 function assertGlobalPatternConfiguration() {