@wazir-dev/cli 1.1.0 → 1.2.0

package/tooling/src/state/db.js

@@ -0,0 +1,287 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+function getStateDatabasePath(stateRoot) {
+  return path.join(stateRoot, 'state', 'state.sqlite');
+}
+
+function hashDescription(description) {
+  return crypto.createHash('sha256').update(description).digest('hex');
+}
+
+function ensureStateSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS learnings (
+      id TEXT PRIMARY KEY,
+      source_run TEXT NOT NULL,
+      category TEXT NOT NULL,
+      scope_roles TEXT DEFAULT '',
+      scope_stacks TEXT DEFAULT '',
+      scope_concerns TEXT DEFAULT '',
+      confidence TEXT DEFAULT 'medium' CHECK(confidence IN ('low','medium','high')),
+      recurrence_count INTEGER DEFAULT 1,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_applied TEXT,
+      expires_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS findings (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      phase TEXT NOT NULL,
+      source TEXT NOT NULL CHECK(source IN ('internal','codex','self-audit','gemini')),
+      severity TEXT NOT NULL CHECK(severity IN ('critical','high','medium','low')),
+      description TEXT NOT NULL,
+      resolved INTEGER DEFAULT 0,
+      finding_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS audit_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL,
+      date TEXT NOT NULL DEFAULT (date('now')),
+      finding_count INTEGER DEFAULT 0,
+      fix_count INTEGER DEFAULT 0,
+      manual_count INTEGER DEFAULT 0,
+      quality_score_before REAL,
+      quality_score_after REAL
+    );
+
+    CREATE TABLE IF NOT EXISTS usage_aggregate (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL,
+      date TEXT NOT NULL DEFAULT (date('now')),
+      tokens_saved INTEGER DEFAULT 0,
+      bytes_avoided INTEGER DEFAULT 0,
+      savings_ratio REAL DEFAULT 0.0,
+      index_queries INTEGER DEFAULT 0,
+      routing_decisions INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_learnings_category ON learnings(category);
+    CREATE INDEX IF NOT EXISTS idx_findings_run_id ON findings(run_id);
+    CREATE INDEX IF NOT EXISTS idx_findings_finding_hash ON findings(finding_hash);
+    CREATE INDEX IF NOT EXISTS idx_audit_history_run_id ON audit_history(run_id);
+    CREATE INDEX IF NOT EXISTS idx_usage_aggregate_run_id ON usage_aggregate(run_id);
+  `);
+}
+
+// ---------------------------------------------------------------------------
+// Database lifecycle
+// ---------------------------------------------------------------------------
+
+export function openStateDb(stateRoot) {
+  const databasePath = getStateDatabasePath(stateRoot);
+  fs.mkdirSync(path.dirname(databasePath), { recursive: true });
+  const db = new DatabaseSync(databasePath, { timeout: 5000 });
+  ensureStateSchema(db);
+  return db;
+}
+
+export function closeStateDb(db) {
+  db.close();
+}
+
+// ---------------------------------------------------------------------------
+// Learnings CRUD
+// ---------------------------------------------------------------------------
+
+export function insertLearning(db, record) {
+  const id = crypto.randomUUID();
+  const createdAt = new Date().toISOString();
+
+  db.prepare(`
+    INSERT INTO learnings (id, source_run, category, scope_roles, scope_stacks, scope_concerns, confidence, content, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    record.source_run,
+    record.category,
+    record.scope_roles ?? '',
+    record.scope_stacks ?? '',
+    record.scope_concerns ?? '',
+    record.confidence ?? 'medium',
+    record.content,
+    createdAt,
+  );
+
+  return id;
+}
+
+export function getLearningsByScope(db, filters = {}) {
+  const conditions = [];
+  const params = [];
+
+  if (filters.roles) {
+    conditions.push("scope_roles LIKE ?");
+    params.push(`%${filters.roles}%`);
+  }
+
+  if (filters.stacks) {
+    conditions.push("scope_stacks LIKE ?");
+    params.push(`%${filters.stacks}%`);
+  }
+
+  if (filters.concerns) {
+    conditions.push("scope_concerns LIKE ?");
+    params.push(`%${filters.concerns}%`);
+  }
+
+  if (filters.confidence) {
+    conditions.push("confidence = ?");
+    params.push(filters.confidence);
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+  const limit = filters.limit ? `LIMIT ${Number(filters.limit)}` : '';
+
+  return db.prepare(`
+    SELECT * FROM learnings ${where} ORDER BY created_at DESC ${limit}
+  `).all(...params);
+}
+
+export function updateLearningRecurrence(db, id) {
+  const now = new Date().toISOString();
+
+  db.prepare(`
+    UPDATE learnings
+    SET recurrence_count = recurrence_count + 1,
+        last_applied = ?
+    WHERE id = ?
+  `).run(now, id);
+}
+
+export function getRecurringLearnings(db, minCount) {
+  return db.prepare(`
+    SELECT * FROM learnings
+    WHERE recurrence_count >= ?
+    ORDER BY recurrence_count DESC
+  `).all(minCount);
+}
+
+// ---------------------------------------------------------------------------
+// Findings CRUD
+// ---------------------------------------------------------------------------
+
+export function insertFinding(db, record) {
+  const id = crypto.randomUUID();
+  const findingHash = record.finding_hash ?? hashDescription(record.description);
+  const createdAt = new Date().toISOString();
+
+  db.prepare(`
+    INSERT INTO findings (id, run_id, phase, source, severity, description, finding_hash, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    record.run_id,
+    record.phase,
+    record.source,
+    record.severity,
+    record.description,
+    findingHash,
+    createdAt,
+  );
+
+  return id;
+}
+
+export function getFindingsByRun(db, runId) {
+  return db.prepare(`
+    SELECT * FROM findings
+    WHERE run_id = ?
+    ORDER BY created_at ASC
+  `).all(runId);
+}
+
+export function getRecurringFindingHashes(db, minOccurrences) {
+  return db.prepare(`
+    SELECT finding_hash, COUNT(*) AS count
+    FROM findings
+    GROUP BY finding_hash
+    HAVING COUNT(*) >= ?
+    ORDER BY count DESC
+  `).all(minOccurrences);
+}
+
+export function resolveFinding(db, id) {
+  db.prepare(`
+    UPDATE findings SET resolved = 1 WHERE id = ?
+  `).run(id);
+}
+
+// ---------------------------------------------------------------------------
+// Audit history
+// ---------------------------------------------------------------------------
+
+export function insertAuditRecord(db, record) {
+  db.prepare(`
+    INSERT INTO audit_history (run_id, finding_count, fix_count, manual_count, quality_score_before, quality_score_after)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(
+    record.run_id,
+    record.finding_count ?? 0,
+    record.fix_count ?? 0,
+    record.manual_count ?? 0,
+    record.quality_score_before ?? null,
+    record.quality_score_after ?? null,
+  );
+}
+
+export function getAuditTrend(db, limit) {
+  const limitClause = limit ? `LIMIT ${Number(limit)}` : '';
+
+  return db.prepare(`
+    SELECT * FROM audit_history
+    ORDER BY date DESC, id DESC
+    ${limitClause}
+  `).all();
+}
+
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
+
+export function insertUsageRecord(db, record) {
+  db.prepare(`
+    INSERT INTO usage_aggregate (run_id, tokens_saved, bytes_avoided, savings_ratio, index_queries, routing_decisions)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(
+    record.run_id,
+    record.tokens_saved ?? 0,
+    record.bytes_avoided ?? 0,
+    record.savings_ratio ?? 0.0,
+    record.index_queries ?? 0,
+    record.routing_decisions ?? 0,
+  );
+}
+
+export function getUsageSummary(db) {
+  const row = db.prepare(`
+    SELECT
+      COALESCE(SUM(tokens_saved), 0) AS total_tokens_saved,
+      COALESCE(SUM(bytes_avoided), 0) AS total_bytes_avoided,
+      CASE WHEN COUNT(*) > 0 THEN AVG(savings_ratio) ELSE 0.0 END AS avg_savings_ratio,
+      COALESCE(SUM(index_queries), 0) AS total_index_queries,
+      COUNT(*) AS run_count
+    FROM usage_aggregate
+  `).get();
+
+  return row;
+}
+
+// ---------------------------------------------------------------------------
+// Stats (for CLI)
+// ---------------------------------------------------------------------------
+
+export function getStateCounts(db) {
+  return {
+    learning_count: db.prepare('SELECT COUNT(*) AS count FROM learnings').get().count,
+    finding_count: db.prepare('SELECT COUNT(*) AS count FROM findings').get().count,
+    audit_count: db.prepare('SELECT COUNT(*) AS count FROM audit_history').get().count,
+    usage_count: db.prepare('SELECT COUNT(*) AS count FROM usage_aggregate').get().count,
+  };
+}

package/tooling/src/status/command.js

@@ -5,6 +5,46 @@ import { parseCommandOptions } from '../command-options.js';
 import { readYamlFile } from '../loaders.js';
 import { findProjectRoot } from '../project-root.js';
 import { resolveStateRoot } from '../state-root.js';
+import { estimateTokens } from '../capture/usage.js';
+
+function readUsageSavingsSummary(stateRoot, runId) {
+  const usagePath = path.join(stateRoot, 'runs', runId, 'usage.json');
+
+  if (!fs.existsSync(usagePath)) {
+    return null;
+  }
+
+  try {
+    const usage = JSON.parse(fs.readFileSync(usagePath, 'utf8'));
+    const cr = usage.savings?.capture_routing ?? {};
+    const cm = usage.savings?.context_mode ?? {};
+    const co = usage.savings?.compaction ?? {};
+    const iq = usage.savings?.index_queries ?? {};
+
+    const crTokensSaved = cr.estimated_tokens_avoided ?? 0;
+    const cmRawTokens = estimateTokens(Math.round((cm.raw_kb ?? 0) * 1024));
+    const cmAfterTokens = estimateTokens(Math.round((cm.context_kb ?? 0) * 1024));
+    const cmTokensSaved = cmRawTokens - cmAfterTokens;
+    const coTokensSaved = (co.pre_compaction_tokens_est ?? 0) - (co.post_compaction_tokens_est ?? 0);
+    const iqTokensSaved = iq.estimated_tokens_saved ?? 0;
+
+    const totalSaved = crTokensSaved + cmTokensSaved + coTokensSaved + iqTokensSaved;
+
+    if (totalSaved === 0) {
+      return null;
+    }
+
+    const crRawTokens = crTokensSaved + estimateTokens(cr.summary_bytes ?? 0);
+    const withoutSavings = crRawTokens + cmRawTokens + (co.pre_compaction_tokens_est ?? 0);
+    const pct = withoutSavings > 0
+      ? `${((totalSaved / withoutSavings) * 100).toFixed(0)}%`
+      : '0%';
+
+    return `Context savings: ~${totalSaved.toLocaleString('en-US')} tokens saved (${pct} reduction)`;
+  } catch {
+    return null;
+  }
+}
 
 function success(payload, options = {}) {
   if (options.json) {
@@ -14,9 +54,15 @@ function success(payload, options = {}) {
     };
   }
 
+  let output = `${payload.run_id} ${payload.phase} ${payload.status}\n`;
+
+  if (payload.savings_summary) {
+    output += `${payload.savings_summary}\n`;
+  }
+
   return {
     exitCode: 0,
-    stdout: `${payload.run_id} ${payload.phase} ${payload.status}\n`,
+    stdout: output,
   };
 }
 
@@ -61,6 +107,12 @@ export function runStatusCommand(parsed, context = {}) {
       status_path: statusPath,
     };
 
+    const savingsSummary = readUsageSavingsSummary(stateRoot, options.run);
+
+    if (savingsSummary) {
+      payload.savings_summary = savingsSummary;
+    }
+
     return success(payload, { json: options.json });
   } catch (error) {
     return {

package/wazir.manifest.yaml

@@ -47,20 +47,31 @@ workflows:
   - prepare_next
   - run_audit
 phases:
-  - clarify
-  - discover
-  - specify
-  - spec_challenge
-  - author
-  - design
-  - design_review
-  - plan
-  - plan_review
-  - execute
-  - verify
-  - review
-  - learn
-  - prepare_next
+  - init
+  - clarifier
+  - executor
+  - final_review
+phase_prerequisites:
+  init: {}
+  clarifier: {}
+  executor:
+    required_artifacts:
+      - clarified/clarification.md
+      - clarified/spec-hardened.md
+      - clarified/design.md
+      - clarified/execution-plan.md
+    required_phase_exits:
+      - clarifier
+  final_review:
+    required_artifacts:
+      - clarified/clarification.md
+      - clarified/spec-hardened.md
+      - clarified/design.md
+      - clarified/execution-plan.md
+      - artifacts/verification-proof.md
+    required_phase_exits:
+      - clarifier
+      - executor
 roles:
   - clarifier
   - researcher
@@ -85,6 +96,7 @@ required_hooks:
   - stop_handoff_harvest
   - protected_path_write_guard
   - loop_cap_guard
+  - context_mode_router
 protected_paths:
   - input
   - roles