@wazir-dev/cli 1.0.0 → 1.1.0

package/tooling/src/cli.js

@@ -8,6 +8,7 @@ import { runValidateCommand } from './commands/validate.js';
 import { runDoctorCommand } from './doctor/command.js';
 import { runExportCommand as runGeneratedExportCommand } from './export/command.js';
 import { runIndexCommand } from './index/command.js';
+import { runInitCommand } from './init/command.js';
 import { runRecallCommand } from './recall/command.js';
 import { runStatusCommand } from './status/command.js';
 
@@ -16,6 +17,7 @@ const COMMAND_FAMILIES = [
   'validate',
   'doctor',
   'index',
+  'init',
   'recall',
   'status',
   'capture'
@@ -26,6 +28,7 @@ const COMMAND_HANDLERS = {
   validate: runValidateCommand,
   doctor: runDoctorCommand,
   index: runIndexCommand,
+  init: runInitCommand,
   recall: runRecallCommand,
   status: runStatusCommand,
   capture: runCaptureCommand,
@@ -63,7 +66,7 @@ export function renderHelp() {
   ].join('\n');
 }
 
-export function main(argv = process.argv.slice(2)) {
+export async function main(argv = process.argv.slice(2)) {
   const parsed = parseArgs(argv);
 
   if (parsed.help || !parsed.command) {
@@ -86,7 +89,7 @@ export function main(argv = process.argv.slice(2)) {
   let result;
 
   try {
-    result = handler(parsed);
+    result = await handler(parsed);
   } catch (error) {
     console.error(error.message);
     return 1;
@@ -112,5 +115,7 @@ function isDirectExecution() {
 }
 
 if (isDirectExecution()) {
-  process.exitCode = main();
+  main().then((code) => {
+    process.exitCode = code;
+  });
 }

package/tooling/src/init/command.js

@@ -0,0 +1,201 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { select } from '@inquirer/prompts';
+
+export async function runInitCommand(parsed, context = {}) {
+  const cwd = context.cwd ?? process.cwd();
+  const wazirDir = path.join(cwd, '.wazir');
+  const configPath = path.join(wazirDir, 'state', 'config.json');
+
+  if (fs.existsSync(configPath) && !parsed.args.includes('--force')) {
+    return {
+      exitCode: 1,
+      stderr: 'Pipeline already initialized. Use --force to reinitialize.\n',
+    };
+  }
+
+  try {
+    // Create directories
+    for (const dir of ['input', 'state', 'runs']) {
+      fs.mkdirSync(path.join(wazirDir, dir), { recursive: true });
+    }
+
+    // Pipeline mode
+    const modelMode = await select({
+      message: 'How should Wazir run in this project?',
+      choices: [
+        { name: 'Single model (Recommended) — slash commands only', value: 'claude-only' },
+        { name: 'Multi-model — routes by complexity (Haiku/Sonnet/Opus)', value: 'multi-model' },
+        { name: 'Multi-tool — current model + external tools for reviews', value: 'multi-tool' },
+      ],
+      default: 'claude-only',
+    });
+
+    // Multi-tool tools (conditional)
+    let multiToolTools = [];
+    if (modelMode === 'multi-tool') {
+      const toolChoice = await select({
+        message: 'Which external tools should Wazir use for reviews?',
+        choices: [
+          { name: 'Codex — Send reviews to OpenAI Codex', value: 'codex' },
+          { name: 'Gemini — Send reviews to Google Gemini', value: 'gemini' },
+          { name: 'Both — Use Codex and Gemini', value: 'both' },
+        ],
+      });
+      multiToolTools = toolChoice === 'both' ? ['codex', 'gemini'] : [toolChoice];
+    }
+
+    // Codex model (conditional)
+    let codexModel = null;
+    if (multiToolTools.includes('codex')) {
+      codexModel = await select({
+        message: 'Which Codex model should Wazir use?',
+        choices: [
+          { name: 'gpt-5.3-codex-spark (Recommended) — fast, good for review loops', value: 'gpt-5.3-codex-spark' },
+          { name: 'gpt-5.4 — slower, deeper analysis for complex reviews', value: 'gpt-5.4' },
+        ],
+        default: 'gpt-5.3-codex-spark',
+      });
+    }
+
+    // Default depth
+    const defaultDepth = await select({
+      message: 'What default depth should runs use?',
+      choices: [
+        { name: 'Quick — minimal research, single-pass review', value: 'quick' },
+        { name: 'Standard (Recommended) — balanced research, multi-pass hardening', value: 'standard' },
+        { name: 'Deep — extended research, strict review thresholds', value: 'deep' },
+      ],
+      default: 'standard',
+    });
+
+    // Default intent
+    const defaultIntent = await select({
+      message: 'What kind of work does this project mostly involve?',
+      choices: [
+        { name: 'Feature (Recommended) — new functionality or enhancement', value: 'feature' },
+        { name: 'Bugfix — fix broken behavior', value: 'bugfix' },
+        { name: 'Refactor — restructure without changing behavior', value: 'refactor' },
+        { name: 'Docs — documentation only', value: 'docs' },
+        { name: 'Spike — research and exploration', value: 'spike' },
+      ],
+      default: 'feature',
+    });
+
+    // Agent Teams (conditional)
+    let teamMode = 'sequential';
+    let parallelBackend = 'none';
+
+    const depthAllows = defaultDepth === 'standard' || defaultDepth === 'deep';
+    const intentAllows = defaultIntent === 'feature' || defaultIntent === 'refactor';
+
+    if (depthAllows && intentAllows) {
+      const useTeams = await select({
+        message: 'Would you like to use Agent Teams for parallel execution?',
+        choices: [
+          { name: 'No (Recommended) — sequential, predictable, lower cost', value: 'sequential' },
+          { name: 'Yes — parallel teammates, faster but experimental (Opus only)', value: 'parallel' },
+        ],
+        default: 'sequential',
+      });
+      teamMode = useTeams;
+      parallelBackend = useTeams === 'parallel' ? 'claude_teams' : 'none';
+
+      if (teamMode === 'parallel') {
+        try {
+          execFileSync('claude', ['config', 'set', 'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS', '1'], { stdio: 'pipe' });
+        } catch {
+          // claude CLI not available — user will need to set it manually
+        }
+      }
+    }
+
+    // Write config
+    const config = {
+      model_mode: modelMode,
+      ...(modelMode === 'multi-tool' && {
+        multi_tool: {
+          tools: multiToolTools,
+          ...(codexModel && { codex: { model: codexModel } }),
+        },
+      }),
+      default_depth: defaultDepth,
+      default_intent: defaultIntent,
+      team_mode: teamMode,
+      parallel_backend: parallelBackend,
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+
+    // Runtime-specific setup
+    const filesCreated = ['.wazir/input/', '.wazir/state/', '.wazir/runs/', '.wazir/state/config.json'];
+
+    if (multiToolTools.includes('codex')) {
+      const content = [
+        '# Wazir Pipeline',
+        '',
+        'Agent protocols are at `~/.claude/agents/` (global).',
+        '',
+        '## Running the Pipeline',
+        '1. Clarifier: read and follow `~/.claude/agents/clarifier.md` — tasks are in `.wazir/input/`',
+        '2. Orchestrator: read and follow `~/.claude/agents/orchestrator.md` — start from task 1',
+        '3. Opus Reviewer: read and follow `~/.claude/agents/opus-reviewer.md` — run all phases',
+        '',
+        '## Review Mode',
+        'This project uses Codex as a secondary reviewer. Review artifacts are in `.wazir/reviews/`.',
+        '',
+      ].join('\n');
+      fs.writeFileSync(path.join(cwd, 'AGENTS.md'), content);
+      filesCreated.push('AGENTS.md');
+    }
+
+    if (multiToolTools.includes('gemini')) {
+      const content = [
+        '# Wazir Pipeline',
+        '',
+        'Agent protocols are at `~/.claude/agents/` (global).',
+        '',
+        '## Running the Pipeline',
+        '1. Clarifier: read and follow `~/.claude/agents/clarifier.md` — tasks are in `.wazir/input/`',
+        '2. Orchestrator: read and follow `~/.claude/agents/orchestrator.md` — start from task 1',
+        '3. Opus Reviewer: read and follow `~/.claude/agents/opus-reviewer.md` — run all phases',
+        '',
+        '## Review Mode',
+        'This project uses Gemini as a secondary reviewer. Review artifacts are in `.wazir/reviews/`.',
+        '',
+      ].join('\n');
+      fs.writeFileSync(path.join(cwd, 'GEMINI.md'), content);
+      filesCreated.push('GEMINI.md');
+    }
+
+    const lines = [
+      '',
+      '\u2705 Pipeline initialized!',
+      '',
+      `  Mode:    ${modelMode}`,
+      `  Depth:   ${defaultDepth}`,
+      `  Intent:  ${defaultIntent}`,
+      `  Teams:   ${teamMode}`,
+      '',
+      'Files created:',
+      ...filesCreated.map((f) => `  - ${f}`),
+      '',
+      'You can now use:',
+      '  /wazir <your request>  \u2014 Run the full pipeline',
+      '  /clarifier             \u2014 Research, clarify, plan',
+      '  /executor              \u2014 Autonomous execution',
+      '  /reviewer              \u2014 Final review and scoring',
+      '',
+    ];
+
+    return {
+      exitCode: 0,
+      stdout: lines.join('\n'),
+    };
+  } catch (error) {
+    if (error.name === 'ExitPromptError') {
+      return { exitCode: 130, stderr: '\nInit cancelled.\n' };
+    }
+    return { exitCode: 1, stderr: `${error.message}\n` };
+  }
+}

package/wazir.manifest.yaml

@@ -92,11 +92,8 @@ protected_paths:
   - schemas
   - exports/hosts
 prohibited_terms:
-  - Agent OS
-  - daemon
   - HTTP control plane
   - web UI
-  - OpenAI Symphony
   - Elixir
 adapters:
   context_mode:

package/workflows/clarify.md

@@ -24,6 +24,10 @@ On entering this phase, run:
 - unresolved questions list
 - scope summary
 
+## Review Loop
+
+Clarification artifact is reviewed by the reviewer role using the review loop pattern with spec/clarification dimensions. The reviewer is invoked with `--mode clarification-review`. The clarifier resolves findings. Clarification does not flow to specify until all review passes complete.
+
 ## Approval Gate
 
 - no formal approval gate, but unresolved material ambiguity must be escalated

package/workflows/design-review.md

@@ -39,6 +39,10 @@ On rejection: `wazir capture event --run <run-id> --event gate_rejected --phase
 On completing this phase, run:
 `wazir capture event --run <run-id> --event phase_exit --phase <phase-name> --status completed`
 
+## Loop Structure
+
+Follows the review loop pattern in `docs/reference/review-loop-pattern.md` with the canonical design-review dimensions (spec coverage, design-spec consistency, accessibility, visual consistency, exported-code fidelity). The designer role resolves findings. Starts when the approved design artifact enters the `design_review` phase. Pass count determined by depth. No extension.
+
 ## Failure Conditions
 
 - vague findings without visual evidence

package/workflows/design.md

@@ -33,6 +33,10 @@ On entering this phase, run:
 
 - explicit human approval required before design-review
 
+## Review Loop
+
+After user approval, design artifact is reviewed via the design-review workflow (`workflows/design-review.md`) using the review loop pattern with the canonical design-review dimensions (spec coverage, design-spec consistency, accessibility, visual consistency, exported-code fidelity). The reviewer is invoked with `--mode design-review`. Design does not flow to planning until all review passes complete.
+
 ## Phase exit
 
 On completing this phase, run:

package/workflows/discover.md

@@ -23,6 +23,10 @@ On entering this phase, run:
 - research artifact
 - cited findings
 
+## Review Loop
+
+Research artifact is reviewed by the reviewer role using the review loop pattern (`docs/reference/review-loop-pattern.md`) with research dimensions (coverage, source quality, relevance, gaps, contradictions). The reviewer is invoked with `--mode research-review`. The researcher resolves findings. Research does not flow to specify until all review passes complete.
+
 ## Approval Gate
 
 - no formal approval gate, but unsupported research cannot flow forward

package/workflows/execute.md

@@ -34,6 +34,10 @@ If either check fails:
 - code and docs changes
 - execution notes
 
+## Per-Task Review
+
+Each task's output is reviewed using the review loop pattern with the 5 task-execution dimensions (correctness, tests, wiring, drift, quality). The reviewer is invoked with `--mode task-review --task-id <NNN>`. This is NOT the final review -- it is a per-task gate. Review happens BEFORE commit. Review logs use task-scoped filenames: `<phase>-task-<NNN>-review-pass-<N>.md`. See `docs/reference/review-loop-pattern.md` for code review scoping rules.
+
 ## Approval Gate
 
 - no new scope without explicit approval

package/workflows/plan-review.md

@@ -37,6 +37,10 @@ On rejection: `wazir capture event --run <run-id> --event gate_rejected --phase
 On completing this phase, run:
 `wazir capture event --run <run-id> --event phase_exit --phase <phase-name> --status completed`
 
+## Loop Structure
+
+Follows the review loop pattern in `docs/reference/review-loop-pattern.md` with plan dimensions. The planner role resolves findings. Pass count determined by depth. No extension.
+
 ## Failure Conditions
 
 - sequence gaps survive review

package/workflows/plan.md

@@ -25,6 +25,10 @@ On entering this phase, run:
 - implementation plan artifact
 - ordered tasks and verification steps
 
+## Review Loop
+
+Plan artifact is reviewed via the plan-review workflow (`workflows/plan-review.md`) using the review loop pattern with plan dimensions. The reviewer is invoked with `--mode plan-review`.
+
 ## Approval Gate
 
 - explicit human approval required before execution

package/workflows/spec-challenge.md

@@ -36,6 +36,10 @@ On rejection: `wazir capture event --run <run-id> --event gate_rejected --phase
 On completing this phase, run:
 `wazir capture event --run <run-id> --event phase_exit --phase <phase-name> --status completed`
 
+## Loop Structure
+
+This workflow IS a review loop. Follows the pattern in `docs/reference/review-loop-pattern.md` with spec/clarification dimensions. The specifier role resolves findings. Loop count tracked via `wazir capture loop-check --mode spec-challenge`. Pass count determined by depth (quick=3, standard=5, deep=7). No extension beyond depth pass count.
+
 ## Failure Conditions
 
 - rubber-stamp review

package/workflows/specify.md

@@ -24,6 +24,10 @@ On entering this phase, run:
 - acceptance criteria
 - assumptions and non-goals
 
+## Review Loop
+
+Spec artifact is reviewed via the spec-challenge workflow (`workflows/spec-challenge.md`) using the review loop pattern with spec dimensions. The reviewer is invoked with `--mode spec-challenge`. The specifier resolves findings.
+
 ## Approval Gate
 
 - explicit human approval required before planning

package/workflows/verify.md

@@ -32,6 +32,10 @@ On entering this phase, run:
 On completing this phase, run:
 `wazir capture event --run <run-id> --event phase_exit --phase <phase-name> --status completed`
 
+## Relationship to Review Loops
+
+Verification is invoked per-task during execution, not as a review loop. It produces deterministic proof, not adversarial findings.
+
 ## Failure Conditions
 
 - stale or partial verification