qualia-framework 7.1.0 → 7.2.1

package/bin/qualia-doctor.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+// ~/.claude/bin/qualia-doctor.js — memory-loop freshness gates for /qualia-doctor.
+//
+// The memory loop (capture → promote → ingest → export) can silently freeze:
+// the audit found raw/sessions/ stale for 23 days with no monitoring. These
+// gates make staleness loud. Each gate prints PASS / WARN / FAIL with the
+// offending detail, so the operator sees exactly which leg of the loop stopped.
+//
+// Usage:
+//   node ~/.claude/bin/qualia-doctor.js           # human-readable gates
+//   node ~/.claude/bin/qualia-doctor.js --json     # machine-readable
+//   node ~/.claude/bin/qualia-doctor.js --exit-code # exit 1 if any gate FAILs
+//
+// Gates:
+//   1. daily-log newest        ≤ 2 days  (capture is alive)
+//   2. flush log last run      ≤ 8 days  (promote/flush is scheduled & running)
+//   3. wiki/_export rebuilt    ≤ 2 days  (export is scheduled & running)
+//   4. export concept count    == allowed source set (export covers all concepts)
+//   5. tags:deprecated         == 0 in _export (no deprecated rows leaked out)
+//
+// Zero-dependency. Resolves the vault from $QUALIA_MEMORY else ~/qualia-memory,
+// and the install home from $QUALIA_HOME else ~/.claude. Missing dirs surface
+// as the gate's offending detail rather than a crash.
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const HOME = os.homedir();
+
+function qualiaHome() {
+  if (process.env.QUALIA_HOME) return process.env.QUALIA_HOME;
+  const parent = path.basename(path.dirname(__dirname));
+  if (parent === ".codex" || parent === ".claude") return path.dirname(__dirname);
+  return path.join(HOME, ".claude");
+}
+function vaultRoot() {
+  return process.env.QUALIA_MEMORY || path.join(HOME, "qualia-memory");
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function ageDays(ms) {
+  return (Date.now() - ms) / DAY_MS;
+}
+
+// Newest mtime among files in a dir (optionally filtered). null if dir absent/empty.
+function newestMtime(dir, filterFn) {
+  if (!fs.existsSync(dir)) return null;
+  let newest = null;
+  let stack = [dir];
+  while (stack.length) {
+    const d = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) { stack.push(p); continue; }
+      if (filterFn && !filterFn(e.name, p)) continue;
+      try {
+        const m = fs.statSync(p).mtimeMs;
+        if (newest === null || m > newest) newest = m;
+      } catch {}
+    }
+  }
+  return newest;
+}
+
+// ── Gate definitions ────────────────────────────────────────────────────
+// Each returns { gate, status: PASS|WARN|FAIL, detail }.
+
+function gateDailyLog(QUALIA_HOME) {
+  const dir = path.join(QUALIA_HOME, "knowledge", "daily-log");
+  const newest = newestMtime(dir, (name) => name.endsWith(".md"));
+  if (newest === null) {
+    return { gate: "daily-log freshness", status: "FAIL", detail: `no daily-log entries at ${dir}` };
+  }
+  const age = ageDays(newest);
+  if (age <= 2) return { gate: "daily-log freshness", status: "PASS", detail: `newest ${age.toFixed(1)}d old (≤2d)` };
+  if (age <= 4) return { gate: "daily-log freshness", status: "WARN", detail: `newest ${age.toFixed(1)}d old (>2d)` };
+  return { gate: "daily-log freshness", status: "FAIL", detail: `newest ${age.toFixed(1)}d old — capture may be dead` };
+}
+
+function gateFlushLog(QUALIA_HOME) {
+  const logFile = path.join(QUALIA_HOME, ".qualia-flush.log");
+  if (!fs.existsSync(logFile)) {
+    return { gate: "flush last-run", status: "FAIL", detail: `no flush log at ${logFile} — flush never ran` };
+  }
+  // Last run = last "ok"/"skipped"/"failed" event timestamp in the JSONL log.
+  let lastTs = null;
+  try {
+    const lines = fs.readFileSync(logFile, "utf8").trim().split("\n").filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const ev = JSON.parse(lines[i]);
+        if (ev.timestamp) { lastTs = Date.parse(ev.timestamp); break; }
+      } catch {}
+    }
+  } catch {}
+  if (lastTs === null || Number.isNaN(lastTs)) {
+    // Fall back to file mtime.
+    try { lastTs = fs.statSync(logFile).mtimeMs; } catch { lastTs = null; }
+  }
+  if (lastTs === null) {
+    return { gate: "flush last-run", status: "FAIL", detail: "flush log unreadable" };
+  }
+  const age = ageDays(lastTs);
+  if (age <= 8) return { gate: "flush last-run", status: "PASS", detail: `last run ${age.toFixed(1)}d ago (≤8d)` };
+  if (age <= 12) return { gate: "flush last-run", status: "WARN", detail: `last run ${age.toFixed(1)}d ago (>8d)` };
+  return { gate: "flush last-run", status: "FAIL", detail: `last run ${age.toFixed(1)}d ago — flush schedule may be broken` };
+}
+
+function gateExportFresh(VAULT) {
+  const exportDir = path.join(VAULT, "wiki", "_export");
+  const newest = newestMtime(exportDir);
+  if (newest === null) {
+    return { gate: "team-export freshness", status: "FAIL", detail: `no export at ${exportDir} — export never ran` };
+  }
+  const age = ageDays(newest);
+  if (age <= 2) return { gate: "team-export freshness", status: "PASS", detail: `rebuilt ${age.toFixed(1)}d ago (≤2d)` };
+  if (age <= 4) return { gate: "team-export freshness", status: "WARN", detail: `rebuilt ${age.toFixed(1)}d ago (>2d)` };
+  return { gate: "team-export freshness", status: "FAIL", detail: `rebuilt ${age.toFixed(1)}d ago — export schedule may be broken` };
+}
+
+// Allowed source set = concept markdown in the vault's source concepts tier
+// (wiki/sessions/concepts/ + wiki/concepts/). Export must cover the same count
+// of concept files (under _export/.../concepts or _export wiki concepts).
+function countConceptMd(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  let n = 0;
+  let stack = [dir];
+  while (stack.length) {
+    const d = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) {
+        if (/concepts?$/i.test(e.name)) stack.push(p);
+        else stack.push(p);
+        continue;
+      }
+      if (e.name.endsWith(".md") && /concepts?[\\/]/i.test(path.relative(dir, p) + "/")) n++;
+    }
+  }
+  return n;
+}
+
+function gateExportCoverage(VAULT) {
+  // Source concepts: the curated/promoted concept tier in the vault.
+  const sourceDirs = [
+    path.join(VAULT, "wiki", "sessions", "concepts"),
+    path.join(VAULT, "wiki", "concepts"),
+  ];
+  let sourceCount = 0;
+  for (const d of sourceDirs) {
+    if (!fs.existsSync(d)) continue;
+    try { sourceCount += fs.readdirSync(d).filter((f) => f.endsWith(".md")).length; } catch {}
+  }
+  const exportRoot = path.join(VAULT, "wiki", "_export");
+  if (!fs.existsSync(exportRoot)) {
+    return { gate: "export concept coverage", status: "FAIL", detail: `no export dir — source has ${sourceCount} concept(s)` };
+  }
+  const exportCount = countConceptMd(exportRoot);
+  if (sourceCount === 0) {
+    return { gate: "export concept coverage", status: "WARN", detail: "no source concepts to cover yet" };
+  }
+  if (exportCount === sourceCount) {
+    return { gate: "export concept coverage", status: "PASS", detail: `${exportCount}/${sourceCount} concepts exported` };
+  }
+  return {
+    gate: "export concept coverage",
+    status: "FAIL",
+    detail: `export has ${exportCount} concept(s), source has ${sourceCount} — export is stale or partial`,
+  };
+}
+
+function gateNoDeprecated(VAULT) {
+  const exportRoot = path.join(VAULT, "wiki", "_export");
+  if (!fs.existsSync(exportRoot)) {
+    return { gate: "no deprecated in export", status: "FAIL", detail: "no export dir to scan" };
+  }
+  const offenders = [];
+  let stack = [exportRoot];
+  while (stack.length) {
+    const d = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) { stack.push(p); continue; }
+      if (!e.name.endsWith(".md")) continue;
+      try {
+        const txt = fs.readFileSync(p, "utf8");
+        // Match `tags: [..., deprecated, ...]`, `tags:deprecated`, or a `deprecated` tag line.
+        if (/tags?\s*:\s*\[?[^\]\n]*\bdeprecated\b/i.test(txt) || /^\s*-\s*deprecated\s*$/im.test(txt)) {
+          offenders.push(path.relative(exportRoot, p));
+        }
+      } catch {}
+    }
+  }
+  if (offenders.length === 0) {
+    return { gate: "no deprecated in export", status: "PASS", detail: "0 deprecated-tagged files" };
+  }
+  return {
+    gate: "no deprecated in export",
+    status: "FAIL",
+    detail: `${offenders.length} deprecated file(s): ${offenders.slice(0, 3).join(", ")}${offenders.length > 3 ? "…" : ""}`,
+  };
+}
+
+function runGates() {
+  const QUALIA_HOME = qualiaHome();
+  const VAULT = vaultRoot();
+  return [
+    gateDailyLog(QUALIA_HOME),
+    gateFlushLog(QUALIA_HOME),
+    gateExportFresh(VAULT),
+    gateExportCoverage(VAULT),
+    gateNoDeprecated(VAULT),
+  ];
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes("--json");
+  const exitCode = args.includes("--exit-code");
+  const results = runGates();
+
+  if (json) {
+    console.log(JSON.stringify({ gates: results }, null, 2));
+  } else {
+    console.log("Memory-loop freshness gates");
+    for (const r of results) {
+      const mark = r.status === "PASS" ? "PASS" : r.status === "WARN" ? "WARN" : "FAIL";
+      console.log(`  [${mark}] ${r.gate} — ${r.detail}`);
+    }
+  }
+
+  const anyFail = results.some((r) => r.status === "FAIL");
+  if (exitCode && anyFail) process.exit(1);
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+} else {
+  module.exports = { runGates, gateDailyLog, gateFlushLog, gateExportFresh, gateExportCoverage, gateNoDeprecated, qualiaHome, vaultRoot };
+}

package/bin/qualia-ui.js

@@ -20,6 +20,10 @@
 //   plan-summary <path/to/plan.md>       — story-file dashboard for a plan
 //   journey-tree [path/to/JOURNEY.md]    — ladder view of all milestones, current highlighted
 //   milestone-complete <num> <name> <next> — celebration banner on milestone close
+//   spine [path/to/JOURNEY.md]           — compact horizontal "you are here" journey map (start banner)
+//   onboard <name>                       — first-run milestone mental-model card (post-install, employees)
+//   phase-complete <num> <name> [k=v…]   — per-phase celebration (tasks, mdone, mtotal, streak, next, nextname)
+//   clockout <name> [k=v…]               — end-of-day report card (phases, tasks, commits, mdone, mtotal, streak, date, erp)
 
 const fs = require("fs");
 const path = require("path");
@@ -127,6 +131,17 @@ function progressBar(phase, total) {
   return `${bar} ${DIM}${pct}%${RESET}`;
 }
 
+// Compact filled/empty tick bar (▰▱) for inline use in cards and the journey
+// spine. Scales `done` of `total` onto `width` ticks. Returns "" when total<1.
+function barTicks(done, total, width) {
+  const w = width || 5;
+  const t = Number(total) || 0;
+  if (t < 1) return "";
+  const d = Math.max(0, Math.min(t, Number(done) || 0));
+  const filled = Math.max(0, Math.min(w, Math.round((d / t) * w)));
+  return `${TEAL}${"▰".repeat(filled)}${DIM2}${"▱".repeat(w - filled)}${RESET}`;
+}
+
 function colorForStatus(s) {
   const colors = {
     setup: DIM,
@@ -410,6 +425,166 @@ function cmdMilestoneComplete(num, name, nextName) {
   console.log("");
 }
 
+// ─── Journey Spine (compact horizontal "you are here") ───
+// One-line milestone ladder with the current milestone marked and a caret
+// beneath it. Rendered by the session-start banner so an employee sees where
+// they are in the arc the instant they open the terminal. Skips itself when
+// there is no real multi-milestone journey to map (nothing to orient against).
+function cmdSpine(journeyPath) {
+  const state = readState();
+  if (!state || !state.ok) return;
+  const current = state.milestone || 1;
+
+  // Milestone list: JOURNEY.md headers first, then state.milestones, else none.
+  let milestones = [];
+  const p = journeyPath || ".planning/JOURNEY.md";
+  try {
+    const content = fs.readFileSync(p, "utf8");
+    const re = /^## Milestone (\d+)\s*·\s*(.+?)\s*(?:\[[^\]]*\])?\r?$/gm;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      milestones.push({ num: parseInt(m[1]), name: m[2].trim() });
+    }
+  } catch {}
+  if (milestones.length === 0 && Array.isArray(state.milestones)) {
+    milestones = state.milestones
+      .map((x, i) => ({ num: x.num || i + 1, name: x.name || x.milestone_name || "" }));
+  }
+  // Nothing to orient against on a single-milestone (or unknown) project.
+  if (milestones.length < 2) return;
+  milestones.sort((a, b) => a.num - b.num);
+
+  // Build the colored spine while tracking the plain-text column of the current
+  // milestone's marker, so the caret lands exactly beneath it.
+  const SEP = "──";
+  const colored = [];
+  const plainSegs = [];
+  let caretCol = -1;
+  for (let i = 0; i < milestones.length; i++) {
+    const ms = milestones[i];
+    const isPast = ms.num < current;
+    const isCurrent = ms.num === current;
+    const marker = isPast ? `${GREEN}●${RESET}`
+      : isCurrent ? `${TEAL}${BOLD}◆${RESET}`
+      : `${DIM2}○${RESET}`;
+    const labelColor = isCurrent ? TEAL + BOLD : isPast ? DIM : WHITE;
+    const labelPlain = `M${ms.num} `;
+    if (isCurrent) {
+      const prefix = plainSegs.length ? plainSegs.join(SEP).length + SEP.length : 0;
+      caretCol = prefix + labelPlain.length; // column of the marker glyph
+    }
+    plainSegs.push(`${labelPlain}●`);
+    colored.push(`${labelColor}M${ms.num}${RESET} ${marker}`);
+  }
+
+  const LABEL_W = 10; // "Journey" label field width (2-space indent added below)
+  console.log("");
+  console.log(`  ${pad(DIM + "Journey" + RESET, LABEL_W)}${colored.join(`${DIM2}${SEP}${RESET}`)}`);
+  if (caretCol >= 0) {
+    console.log(`  ${" ".repeat(LABEL_W + caretCol)}${TEAL}↑${RESET} ${DIM}you are here${RESET}`);
+  }
+  const last = (state.last_activity || "").trim();
+  if (last && !/regenerated from increments/i.test(last)) {
+    const short = last.length > 56 ? last.slice(0, 55) + "…" : last;
+    console.log(`  ${pad(DIM + "Last" + RESET, LABEL_W)}${DIM}${short}${RESET}`);
+  }
+  console.log("");
+}
+
+// ─── Onboard (first-run mental model for a new employee) ─
+// Shown after install for non-OWNER roles: the milestone mental model + the one
+// first move. Keeps a new hire from staring at a prompt wondering what to type.
+function cmdOnboard(name) {
+  const who = name ? ` ${DIM}·${RESET} ${WHITE}welcome aboard, ${name}${RESET}` : ` ${DIM}·${RESET} ${WHITE}welcome aboard${RESET}`;
+  console.log("");
+  console.log(`  ${TEAL}${BOLD}⬢${RESET} ${WHITE}${BOLD}QUALIA${RESET}${who}`);
+  console.log(`  ${RULE_DIM}`);
+  console.log(`  ${WHITE}You build in milestones:${RESET}  ${TEAL}Plan ${DIM}→ ${TEAL}Build ${DIM}→ ${TEAL}Verify ${DIM}→ ${TEAL}Ship${RESET}`);
+  console.log(`  ${DIM}You never have to guess what's next — the statusline shows where you are,${RESET}`);
+  console.log(`  ${DIM}and ${RESET}${TEAL}/qualia${RESET}${DIM} always tells you the next command.${RESET}`);
+  console.log(`  ${RULE_DIM}`);
+  console.log(`  ${TEAL}⟶${RESET} ${WHITE}First move:${RESET}  ${TEAL}${BOLD}/qualia${RESET}`);
+  console.log("");
+}
+
+// ─── Phase Complete (per-phase celebration + next move) ──
+// Smaller sibling of milestone-complete, shown by /qualia-build (or /qualia-ship)
+// when a phase closes. Optional metrics passed as key=value (tasks, mdone,
+// mtotal, streak, next, nextname); any omitted metric is simply not rendered.
+function cmdPhaseComplete(num, name, kv) {
+  kv = kv || {};
+  console.log("");
+  const title = name ? ` ${DIM}·${RESET} ${TEAL}${name}${RESET}` : "";
+  console.log(`  ${GREEN}${BOLD}◆${RESET} ${WHITE}${BOLD}PHASE ${num} COMPLETE${RESET}${title}`);
+  console.log(`  ${RULE_DIM}`);
+  const checks = [];
+  if (kv.tasks) checks.push(`${GREEN}✓${RESET} ${WHITE}${kv.tasks} tasks${RESET}`);
+  checks.push(`${GREEN}✓${RESET} ${WHITE}verified${RESET}`);
+  checks.push(`${GREEN}✓${RESET} ${WHITE}shipped${RESET}`);
+  console.log(`  ${checks.join("   ")}`);
+  if (kv.mdone && kv.mtotal) {
+    const d = parseInt(kv.mdone, 10), t = parseInt(kv.mtotal, 10);
+    const remaining = t - d;
+    const tail = remaining <= 0 ? `${GREEN}milestone ready to close${RESET}`
+      : remaining === 1 ? `${DIM}one more to close the milestone${RESET}`
+      : `${DIM}${remaining} phases left in this milestone${RESET}`;
+    console.log(`  ${pad(DIM + "Milestone" + RESET, 11)}${barTicks(d, t)} ${DIM}${d}/${t} phases · ${RESET}${tail}`);
+  }
+  if (kv.streak && parseInt(kv.streak, 10) > 1) {
+    console.log(`  ${YELLOW}🔥 ${kv.streak} phases shipped today${RESET}`);
+  }
+  console.log(`  ${RULE_DIM}`);
+  if (kv.next) {
+    const nn = kv.nextname ? `   ${DIM}(${kv.nextname})${RESET}` : "";
+    console.log(`  ${TEAL}⟶${RESET} ${WHITE}Next:${RESET}  ${TEAL}${BOLD}${kv.next}${RESET}${nn}`);
+  }
+  console.log("");
+}
+
+// ─── Clock Out (end-of-day report card) ──────────────────
+// Rendered by /qualia-report at shift close. Metrics passed as key=value
+// (phases, tasks, commits, mdone, mtotal, streak, date, erp=ok|queued).
+function cmdClockout(name, kv) {
+  kv = kv || {};
+  console.log("");
+  const who = name ? ` ${DIM}·${RESET} ${WHITE}${name}${RESET}` : "";
+  const date = kv.date ? ` ${DIM}·${RESET} ${DIM}${kv.date}${RESET}` : "";
+  console.log(`  ${TEAL}${BOLD}▤${RESET} ${WHITE}${BOLD}CLOCK OUT${RESET}${who}${date}`);
+  console.log(`  ${RULE_DIM}`);
+  const shipped = [];
+  if (kv.phases) shipped.push(`${WHITE}${kv.phases} phases${RESET}`);
+  if (kv.tasks) shipped.push(`${WHITE}${kv.tasks} tasks${RESET}`);
+  if (kv.commits) shipped.push(`${WHITE}${kv.commits} commits${RESET}`);
+  if (shipped.length) {
+    console.log(`  ${pad(DIM + "Shipped" + RESET, 12)}${shipped.join(`  ${DIM}·${RESET}  `)}`);
+  }
+  if (kv.mdone && kv.mtotal) {
+    const d = parseInt(kv.mdone, 10), t = parseInt(kv.mtotal, 10);
+    const pct = t > 0 ? Math.round((d / t) * 100) : 0;
+    console.log(`  ${pad(DIM + "Milestone" + RESET, 12)}${barTicks(d, t)} ${DIM}${pct}%${RESET}`);
+  }
+  if (kv.streak && parseInt(kv.streak, 10) >= 1) {
+    console.log(`  ${pad(DIM + "Streak" + RESET, 12)}${YELLOW}${kv.streak} days${RESET}`);
+  }
+  console.log(`  ${RULE_DIM}`);
+  const tail = kv.erp === "ok" ? `${GREEN}Report uploaded to ERP ✓${RESET}`
+    : kv.erp === "queued" ? `${YELLOW}Report queued — uploads next session${RESET}`
+    : `${DIM}Session report saved${RESET}`;
+  console.log(`  ${tail}   ${DIM}See you tomorrow.${RESET}`);
+  console.log("");
+}
+
+// Parse trailing `key=value` CLI args into an object (used by the lifecycle
+// cards so optional metrics are positional-order-independent).
+function parseKV(args) {
+  const o = {};
+  for (const a of args || []) {
+    const i = a.indexOf("=");
+    if (i > 0) o[a.slice(0, i)] = a.slice(i + 1);
+  }
+  return o;
+}
+
 // ─── Plan Summary (story-file dashboard) ─────────────────
 // Renders a polished overview of a plan file: phase goal, tasks grouped by wave,
 // persona chips, dependency lines, AC count, validation count. Called by
@@ -733,6 +908,12 @@ module.exports = {
   divider,
   section,
   sectionClose,
+  // Lifecycle cards (called in-process by install.js / reused by skills)
+  onboard: cmdOnboard,
+  phaseComplete: cmdPhaseComplete,
+  clockout: cmdClockout,
+  spine: cmdSpine,
+  barTicks,
   // Existing helpers (kept exposed for reuse)
   pad,
   visibleLength,
@@ -776,9 +957,13 @@ switch (cmd) {
   case "plan-summary": cmdPlanSummary(rest[0]); break;
   case "journey-tree": cmdJourneyTree(rest[0]); break;
   case "milestone-complete": cmdMilestoneComplete(rest[0], rest[1], rest.slice(2).join(" ")); break;
+  case "spine":    cmdSpine(rest[0]); break;
+  case "onboard":  cmdOnboard(rest.join(" ")); break;
+  case "phase-complete": cmdPhaseComplete(rest[0], rest[1] || "", parseKV(rest.slice(2))); break;
+  case "clockout": cmdClockout(rest[0] || "", parseKV(rest.slice(1))); break;
   default:
     console.error(
-      `Usage: qualia-ui.js <banner|context|divider|ok|fail|warn|info|spawn|wave|task|done|next|end|update|plan-summary|journey-tree|milestone-complete> [args]`
+      `Usage: qualia-ui.js <banner|context|divider|ok|fail|warn|info|spawn|wave|task|done|next|end|update|plan-summary|journey-tree|milestone-complete|spine|onboard|phase-complete|clockout> [args]`
     );
     process.exit(1);
 }

package/bin/runtime-manifest.js

@@ -43,6 +43,7 @@ const RUNTIME_BIN_SCRIPTS = [
   { file: "learning-candidates.js", label: "learning-candidates.js (scan recent commits + daily-log for patterns worth promoting)" },
   { file: "status-snapshot.js", label: "status-snapshot.js (portable operator snapshot — install + project + work + ERP + memory)" },
   { file: "security-scan.js", label: "security-scan.js (static security scanner for agent config — secrets, permissions, hook hygiene)" },
+  { file: "qualia-doctor.js", label: "qualia-doctor.js (memory-loop freshness gates for /qualia-doctor)" },
 ];
 
 function binFiles() {

package/bin/statusline.js

@@ -205,7 +205,13 @@ try {
       parts.push(mStr);
     }
 
-    if (total > 0) parts.push(`P${phase}/${total}`);
+    if (total > 0) {
+      // Always-visible forward-motion bar: phase of total, scaled to 5 ticks.
+      const w = 5;
+      const filled = Math.max(0, Math.min(w, Math.round((phase / total) * w)));
+      const ticks = "▰".repeat(filled) + "▱".repeat(w - filled);
+      parts.push(`P${phase}/${total} ${ticks}`);
+    }
     if (tasksTotal > 0) parts.push(`T${tasksDone}/${tasksTotal}`);
     if (status) parts.push(status);
 

package/guide.md

@@ -3,7 +3,7 @@
 > Follow the road. Type the commands. The framework handles the rest.
 > `--auto` chains the whole road end-to-end with only two human checkpoints per project.
 
-Surface: **25 active skills**. Use `/qualia-fix` for broken behavior, `/qualia-feature` for new single-feature work, `/qualia-scope` in PROJECT MODE for kickoff capture, `/qualia-polish --loop` for the autonomous visual loop, and `/qualia-polish --vibe` for fast layout-preserving aesthetic pivots.
+Surface: **28 active skills** (`skills/` is the source of truth — run `qualia-framework doctor` for the live list). Use `/qualia-fix` for broken behavior, `/qualia-feature` for new single-feature work, `/qualia-scope` in PROJECT MODE for kickoff capture, `/qualia-polish --loop` for the autonomous visual loop, and `/qualia-polish --vibe` for fast layout-preserving aesthetic pivots.
 
 For the identity statement see [`SOUL.md`](./SOUL.md). For every skill flag see [`FLAGS.md`](./FLAGS.md). When something breaks see [`TROUBLESHOOTING.md`](./TROUBLESHOOTING.md). For release history see [`CHANGELOG.md`](./CHANGELOG.md).
 
@@ -73,6 +73,11 @@ Append `--auto` to `/qualia-new` and the framework chains every step:
 | Road view | `/qualia-road` | View and navigate journey/milestone/phase status |
 | Lost — need next command | `/qualia` | Mechanical state-driven router |
 | Confused — need to understand the situation | `/qualia-idk` | Three-scan diagnostic + paste-ready command sequence |
+| Post-launch change | `/qualia-update` | Ship one update to a LAUNCHED project (lean plan → build → verify → ship, no milestone machinery) |
+| Security scan | `/qualia-secure` | Scan agent config (CLAUDE.md / settings / hooks / MCP) for injection, leaked secrets, unscoped perms |
+| AI-feature gate | `/qualia-eval` | Evaluate an AI feature (chat / RAG / voice / agent) against a layered eval suite and gate on the result |
+| Recall prior knowledge | `/qualia-recall` | OWNER-only — recall curated lessons from the knowledge layer + qualia-memory vault |
+| Health check | `/qualia-doctor` | Framework health — install, project state, contracts, hooks, memory, ERP queue + safe repair suggestions |
 
 ## Full Journey Hierarchy
 

package/hooks/session-start.js

@@ -225,6 +225,7 @@ try {
     fallbackText();
   } else if (fs.existsSync(STATE_FILE)) {
     runUi("banner", "router");
+    runUi("spine"); // horizontal "you are here" journey map (self-skips if <2 milestones)
     renderWorkPacketContext();
     const next = getNextCommand();
     if (next) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualia-framework",
-  "version": "7.1.0",
+  "version": "7.2.1",
   "description": "Claude Code and Codex workflow framework by Qualia Solutions. Plan, build, verify, ship.",
   "bin": {
     "qualia-framework": "./bin/cli.js"

package/rules/infrastructure.md

@@ -46,8 +46,10 @@ Standard services across all Qualia projects. Use these unless the project expli
 - `gh` — GitHub CLI (PRs, issues, repos)
 
 ## GitHub Organizations
-- **QualiasolutionsCY** — primary org for all Qualia Solutions projects
-- **SakaniQualia** — org for Sakani-related projects (real estate platform)
+> Canonical slugs (verified via `gh repo list`). This list is the single source of truth — other docs reference it, they do not restate it.
+- **`Qualiasolutions`** — the home of the four core Qualia systems (`qualia-framework`, `qualia-memory`, `qualia-erp`, `qualiafinal`). Default target for internal/system repos.
+- **`QualiaSolutionsCY`** — org for client/delivery projects (e.g. USD-Academy, innrvo). Default target for new client work.
+- **`SakaniQualia`** — org for Sakani-related projects (real estate platform).
 - All repos are private by default
 - Main integration: feature branches integrate to `main` at **`/qualia-ship`** (ship is the single merge point — it fast-forwards the branch into `main`, deploys from `main`, and deletes the branch). Pushes to `main` are **allowed and recorded** by `branch-guard` (per-employee tally → ERP) — accountability, not a hard block. `/qualia-report` sweeps for branches with unshipped commits + stale PRs at clock-out so nothing lingers. Keep GitHub branch protection on `main` OFF (or with the team allowed to push) for this model; if you re-enable required reviews, switch ship to an auto-merged PR instead.
 

package/skills/qualia-doctor/SKILL.md

@@ -92,6 +92,29 @@ node ${QUALIA_BIN}/knowledge.js list
 
 Healthy memory has at least `index.md`, `agents.md`, and a writable `daily-log/` directory. Missing curated memory is not fatal, but missing installed memory files means reinstall.
 
+### 5a. Memory-loop freshness gates
+
+The memory loop (capture → promote/flush → ingest ERP → export team wiki) can silently freeze — the audit found capture stale for 23 days with zero monitoring. Run the freshness gates:
+
+```bash
+node ${QUALIA_BIN}/qualia-doctor.js
+```
+
+It prints PASS / WARN / FAIL with the offending detail for five gates:
+
+1. **daily-log freshness** — newest `knowledge/daily-log/*.md` ≤ 2 days old (capture is alive).
+2. **flush last-run** — `.qualia-flush.log` last event ≤ 8 days ago (the nightly flush is scheduled and running).
+3. **team-export freshness** — `${QUALIA_MEMORY:-~/qualia-memory}/wiki/_export` rebuilt ≤ 2 days ago (export is scheduled and running).
+4. **export concept coverage** — `_export` concept count == the vault source concept set (`wiki/sessions/concepts/` + `wiki/concepts/`); a mismatch means the export is stale or partial.
+5. **no deprecated in export** — zero `tags: deprecated` files in `_export` (deprecated rows must not leak into the published team snapshot).
+
+Any **FAIL** means a leg of the loop stopped. Repair routing:
+- daily-log FAIL → capture (Stop hook) not firing → reinstall to re-wire the `Stop` hook.
+- flush / export FAIL → the nightly `qualia-loop.timer` is not running → `systemctl --user status qualia-loop.timer`, or reinstall (`npx qualia-framework@latest install`) to re-install the timer.
+- coverage / deprecated FAIL → run the vault export manually (`python3 ~/qualia-memory/scripts/export-team-wiki.py`) and investigate the offending file.
+
+These gates are advisory in `qualia-framework doctor` (they render under `Memory loop:`) and exit-coded when run with `--exit-code`.
+
 ## 6. ERP Queue Health
 
 Run:
@@ -180,6 +203,7 @@ State ledger: ...
 Contracts: ...
 Planning hygiene: ...
 Memory: ...
+Memory loop: ...
 Design/UI: ...
 Employee experience: ...
 Env: ...
@@ -188,7 +212,7 @@ ERP: ...
 Next: ...
 ```
 
-`Env` summarizes section 7's env-var check (PASS / DEGRADED / BLOCKED (owner key needed) / N/A). `CLI auth` summarizes the vercel/supabase/gh login checks (PASS if all three are authenticated, else DEGRADED with the first failing CLI named).
+`Env` summarizes section 7's env-var check (PASS / DEGRADED / BLOCKED (owner key needed) / N/A). `CLI auth` summarizes the vercel/supabase/gh login checks (PASS if all three are authenticated, else DEGRADED with the first failing CLI named). `Memory loop` summarizes section 5a's five freshness gates (PASS if all PASS, WARN if any WARN, FAIL if any FAIL, naming the first failing gate).
 
 ## Rules
 

package/skills/qualia-polish/SKILL.md

@@ -299,7 +299,7 @@ polish({scope}): {brief summary}
 - {key change 2}
 - rubric scores: typography {N}, color {N}, graphics {N}, ..., aggregate {N}/45
 
-Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
 EOF
 )"
 ```

package/skills/qualia-report/SKILL.md

@@ -155,6 +155,17 @@ fi
 node ${QUALIA_BIN}/qualia-ui.js divider
 node ${QUALIA_BIN}/qualia-ui.js ok "Report $CLIENT_REPORT_ID complete."
 node ${QUALIA_BIN}/qualia-ui.js info "Shift report submitted. You can clock out now."
+
+# End-of-day report card. Name from config; commits = $COUNT; milestone
+# progress from state. erp=ok when the upload confirmed, erp=queued when it was
+# enqueued for retry. Every metric self-omits if its variable is empty.
+EMP_NAME=$(node -pe 'try{JSON.parse(require("fs").readFileSync(process.env.HOME+"/.claude/.qualia-config.json","utf8")).installed_by||""}catch{""}' 2>/dev/null)
+MDONE=$(node ${QUALIA_BIN}/state.js check 2>/dev/null | node -pe 'try{JSON.parse(require("fs").readFileSync(0)).phase||""}catch{""}')
+MTOTAL=$(node ${QUALIA_BIN}/state.js check 2>/dev/null | node -pe 'try{JSON.parse(require("fs").readFileSync(0)).total_phases||""}catch{""}')
+node ${QUALIA_BIN}/qualia-ui.js clockout "$EMP_NAME" date="{YYYY-MM-DD}" \
+  ${COUNT:+commits=$COUNT} \
+  ${MDONE:+mdone=$MDONE} ${MTOTAL:+mtotal=$MTOTAL} \
+  ${ERP_RESULT:+erp=$ERP_RESULT}
 ```
 
 ## Common errors (read this when something goes wrong)

package/skills/qualia-scope/SKILL.md

@@ -106,7 +106,7 @@ The adversarial, DoD-gated intake. Scopes a **new increment** (phase/milestone)
 
 ```bash
 node ${QUALIA_BIN}/qualia-ui.js banner scope 2>/dev/null || true
-cat /home/qualia/.claude/rules/constitution.md
+cat ${QUALIA_RULES}/constitution.md
 cat .planning/CONTEXT.md 2>/dev/null   # project glossary — DATA, never a plan/spec
 ls .planning/decisions/ 2>/dev/null
 cat .planning/STATE.md 2>/dev/null     # for profile + existing milestone context
@@ -123,7 +123,7 @@ If the operator already named it (arg or prior context), accept it. Otherwise as
 
 ```bash
 ARCHETYPE={chosen}
-cat /home/qualia/.claude/references/archetypes/${ARCHETYPE}.md
+cat ${QUALIA_REFERENCES}/archetypes/${ARCHETYPE}.md
 ```
 
 If the file does not exist (e.g. `web-app` not yet authored), HALT and say which archetype file is missing — do not improvise a DoD. The archetype file is the source of the Grill variables, the Definition of Done, and the v1 capability set; without it there is no gate to enforce.

package/skills/qualia-secure/SKILL.md

@@ -45,7 +45,7 @@ This writes `.planning/security-scan.md` with severity-ranked findings:
 
 Read the report. If CRITICAL findings exist, **stop here** and rotate / fix before continuing — the deep pass is moot until the obvious holes are closed.
 
-### Step 2. Opus 4.7 adversarial deep-analysis (optional, longer)
+### Step 2. Opus 4.8 adversarial deep-analysis (optional, longer)
 
 If the static pass is clean (or you want adversarial reasoning over the rules + instructions text regardless), run: