qualia-framework 7.2.0 → 7.2.2

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualia-framework",
-  "version": "7.2.0",
+  "version": "7.2.2",
   "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/SKILL.md

@@ -39,6 +39,12 @@ node ${QUALIA_BIN}/last-report.js 2>/dev/null
 ```
 Exit 0 → it prints a one-line digest of the newest session report (`Last session ({date}, {age}d ago): {summary} → next: {next}`). Exit 1 → no reports yet (nothing to surface). When a project is loaded and a digest exists, print that line **at the very TOP of your output**, before the banner — so the first thing the operator (or a teammate picking the project up) sees is exactly where the last session ended.
 
+Surface a pending framework update — read the same sticky notice the session-start banner uses (written by `auto-update.js` when npm ships a newer version), so an operator who only ever types `/qualia` still learns an update is out:
+```bash
+node -e "try{const fs=require('fs'),os=require('os'),p=require('path');const h=process.env.QUALIA_HOME||p.join(os.homedir(),'.claude');const n=JSON.parse(fs.readFileSync(p.join(h,'.qualia-update-available.json'),'utf8'));const cur=(JSON.parse(fs.readFileSync(p.join(h,'.qualia-config.json'),'utf8')).version)||n.current;if(n&&n.latest&&n.latest!==cur)console.log('UPDATE_AVAILABLE '+cur+' -> '+n.latest)}catch{}"
+```
+If it prints `UPDATE_AVAILABLE {cur} -> {latest}`, show one line at the **very top** of your reply (above the last-session digest and banner): `▲ Framework update available: v{cur} → v{latest}. Run: npx qualia-framework@latest install`. If it prints nothing, say nothing. Never run a live `npm view` here — `/qualia` must stay instant; this only reads the cached notice.
+
 Read conversation context — what has the user been doing, what errors occurred.
 
 ### 2. Classify and Route

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-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:
 

package/skills/zoho-workflow/SKILL.md

@@ -2,6 +2,14 @@
 name: zoho-workflow
 description: "Zoho Invoice + Mail ops via ERP-first routing. Invoices from templates, cover emails, contacts, inbox, payment reminders. Triggers: 'invoice this client', 'send an email', 'check inbox', 'create a Zoho contact', 'payment reminder'."
 tags: [zoho, invoice, email, billing, crm]
+# Money-moving + client-comms skill — least-privilege scope. ERP-first routing
+# (mcp__qualia-erp__*) is preferred; raw Zoho Books/Mail are the fallback surface.
+allowed-tools:
+  - Bash
+  - Read
+  - mcp__qualia-erp__*
+  - mcp__claude_ai_Zoho_Books__*
+  - mcp__claude_ai_Mail__*
 ---
 
 # Zoho Workflow

package/tests/fixtures/r6-golden-fail-panel.json

@@ -0,0 +1,23 @@
+{
+  "_comment": "R6 golden verifier fixture — a SEEDED STUB the verifier MUST score FAIL. This proves the deterministic verifier (bin/verify-panel.js) cannot default-pass. The fixture contains (a) a surviving CRITICAL finding voted real by majority, and (b) an unvoted HIGH (INSUFFICIENT-EVIDENCE-style: unverified != disproven). Both survive the skeptic round, so the verdict MUST be FAIL (exit 1). If verify-panel ever regresses to a default-3/PASS, r6-golden.test.sh turns red.",
+  "phase": 99,
+  "lenses": ["security", "correctness"],
+  "findings": [
+    {
+      "lens": "security",
+      "file": "lib/supabase/client.ts",
+      "line": 12,
+      "severity": "CRITICAL",
+      "title": "service_role key imported into a client component (auth bypass)",
+      "votes": { "real": 3, "notReal": 0 }
+    },
+    {
+      "lens": "correctness",
+      "file": "app/api/checkout/route.ts",
+      "line": 47,
+      "severity": "HIGH",
+      "title": "INSUFFICIENT EVIDENCE — payment idempotency unverified, no test backs the happy path",
+      "votes": { "real": 0, "notReal": 0 }
+    }
+  ]
+}

package/tests/lib.test.sh

@@ -532,7 +532,7 @@ TMP=$(mktmp)
 mkdir -p "$TMP/home/.claude/bin" "$TMP/home/.claude/hooks" "$TMP/home/.claude/knowledge/daily-log" "$TMP/home/.claude/qualia-design" "$TMP/home/.claude/agents" "$TMP/home/.claude/qualia-templates" "$TMP/project"
 echo '{"installed_by":"Test","role":"OWNER","version":"6.3.0","erp":{"enabled":false}}' > "$TMP/home/.claude/.qualia-config.json"
 touch "$TMP/home/.claude/CLAUDE.md" "$TMP/home/.claude/settings.json"
-for f in runtime-manifest.js command-surface.js host-adapters.js state.js qualia-ui.js statusline.js knowledge.js knowledge-flush.js recall.js vault-access.js repo-map.js design-tokens.js batch-plan.js state-ledger.js plan-contract.js contract-runner.js agent-status.js analyze-gate.js verify-panel.js wave-plan.js eval-runner.js branch-hygiene.js last-report.js harness-eval.js trust-score.js agent-runs.js slop-detect.mjs dep-verify.mjs erp-retry.js erp-event.js work-packet.js report-payload.js project-snapshot.js project-sync.js codex-goal.js planning-hygiene.js prune-deprecated.js learning-candidates.js status-snapshot.js security-scan.js auto-report.js; do
+for f in runtime-manifest.js command-surface.js host-adapters.js state.js qualia-ui.js statusline.js knowledge.js knowledge-flush.js recall.js vault-access.js repo-map.js design-tokens.js batch-plan.js state-ledger.js plan-contract.js contract-runner.js agent-status.js analyze-gate.js verify-panel.js wave-plan.js eval-runner.js branch-hygiene.js last-report.js harness-eval.js trust-score.js agent-runs.js slop-detect.mjs dep-verify.mjs erp-retry.js erp-event.js work-packet.js report-payload.js project-snapshot.js project-sync.js codex-goal.js planning-hygiene.js prune-deprecated.js learning-candidates.js status-snapshot.js security-scan.js qualia-doctor.js auto-report.js; do
   touch "$TMP/home/.claude/bin/$f"
 done
 for h in session-start.js auto-update.js branch-guard.js pre-push.js pre-deploy-gate.js migration-guard.js git-guardrails.js stop-session-log.js fawzi-approval-guard.js vercel-account-guard.js env-empty-guard.js supabase-destructive-guard.js secret-guard.js; do
@@ -647,7 +647,7 @@ TMP=$(mktmp)
 mkdir -p "$TMP/.claude/bin" "$TMP/.claude/hooks" "$TMP/.claude/knowledge/daily-log" "$TMP/.claude/qualia-design" "$TMP/.claude/agents" "$TMP/.claude/qualia-templates" "$TMP/project/.planning"
 echo '{"installed_by":"Test","role":"OWNER","erp":{"enabled":false}}' > "$TMP/.claude/.qualia-config.json"
 touch "$TMP/.claude/CLAUDE.md" "$TMP/.claude/settings.json"
-for f in runtime-manifest.js command-surface.js host-adapters.js state.js qualia-ui.js statusline.js knowledge.js knowledge-flush.js recall.js vault-access.js repo-map.js design-tokens.js batch-plan.js state-ledger.js plan-contract.js contract-runner.js agent-status.js analyze-gate.js verify-panel.js wave-plan.js eval-runner.js branch-hygiene.js last-report.js harness-eval.js trust-score.js agent-runs.js slop-detect.mjs dep-verify.mjs erp-retry.js erp-event.js work-packet.js report-payload.js project-snapshot.js project-sync.js codex-goal.js planning-hygiene.js prune-deprecated.js learning-candidates.js status-snapshot.js security-scan.js auto-report.js; do
+for f in runtime-manifest.js command-surface.js host-adapters.js state.js qualia-ui.js statusline.js knowledge.js knowledge-flush.js recall.js vault-access.js repo-map.js design-tokens.js batch-plan.js state-ledger.js plan-contract.js contract-runner.js agent-status.js analyze-gate.js verify-panel.js wave-plan.js eval-runner.js branch-hygiene.js last-report.js harness-eval.js trust-score.js agent-runs.js slop-detect.mjs dep-verify.mjs erp-retry.js erp-event.js work-packet.js report-payload.js project-snapshot.js project-sync.js codex-goal.js planning-hygiene.js prune-deprecated.js learning-candidates.js status-snapshot.js security-scan.js qualia-doctor.js auto-report.js; do
   touch "$TMP/.claude/bin/$f"
 done
 for h in session-start.js auto-update.js branch-guard.js pre-push.js pre-deploy-gate.js migration-guard.js git-guardrails.js stop-session-log.js fawzi-approval-guard.js vercel-account-guard.js env-empty-guard.js supabase-destructive-guard.js secret-guard.js; do

package/tests/memory-loop.test.sh

@@ -0,0 +1,136 @@
+#!/bin/bash
+# memory-loop.test.sh — the one-loop contract: knowledge-flush vault dual-write
+# (ITEM 13) + qualia-doctor freshness gates (ITEM 14b).
+#
+# Pure-function tests, no agent CLI, no live vault. Each builds a temp QUALIA_HOME
+# and QUALIA_MEMORY so the loop logic is exercised hermetically.
+#
+# Run: bash tests/memory-loop.test.sh
+
+PASS=0
+FAIL=0
+DIR="$(cd "$(dirname "$0")" && pwd)"
+BIN_DIR="$(cd "$DIR/../bin" && pwd)"
+NODE="${NODE:-node}"
+FLUSH="$BIN_DIR/knowledge-flush.js"
+DOCTOR="$BIN_DIR/qualia-doctor.js"
+
+assert_contains() {
+  local name="$1" hay="$2" needle="$3"
+  if echo "$hay" | grep -qF "$needle"; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (missing '$needle' in: $hay)"; FAIL=$((FAIL+1)); fi
+}
+assert_ok() {
+  local name="$1" rc="$2"
+  if [ "$rc" -eq 0 ]; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (rc=$rc)"; FAIL=$((FAIL+1)); fi
+}
+
+echo "memory-loop.test.sh — dual-write + freshness gates"
+echo ""
+
+# --- syntax ---
+$NODE -c "$FLUSH" 2>/dev/null && { echo "  ✓ knowledge-flush.js syntax"; PASS=$((PASS+1)); } || { echo "  ✗ knowledge-flush.js syntax"; FAIL=$((FAIL+1)); }
+$NODE -c "$DOCTOR" 2>/dev/null && { echo "  ✓ qualia-doctor.js syntax"; PASS=$((PASS+1)); } || { echo "  ✗ qualia-doctor.js syntax"; FAIL=$((FAIL+1)); }
+
+# ── ITEM 13: dualWriteVault mirrors curated concepts into the vault ──────────
+TMP=$(mktemp -d); mkdir -p "$TMP/vault"
+OUT=$(QUALIA_HOME="$TMP/home" QUALIA_MEMORY="$TMP/vault" $NODE -e '
+const fs=require("fs"),path=require("path");
+const kh=process.env.QUALIA_HOME;
+fs.mkdirSync(path.join(kh,"knowledge","concepts"),{recursive:true});
+fs.writeFileSync(path.join(kh,"knowledge","learned-patterns.md"),"# Patterns\n- always RLS\n");
+fs.writeFileSync(path.join(kh,"knowledge","concepts","voice-call-state.md"),"# Voice\nstate\n");
+const m=require("'"$FLUSH"'");
+const r1=m.dualWriteVault();
+const files1=fs.readdirSync(m.VAULT_CONCEPTS_DIR).sort();
+const r2=m.dualWriteVault();
+const files2=fs.readdirSync(m.VAULT_CONCEPTS_DIR).sort();
+console.log("detail="+r1.event_detail);
+console.log("written="+r1.written);
+console.log("idempotent="+(files1.length===files2.length && files1.join(",")===files2.join(",")));
+console.log("files="+files2.join(","));
+const sample=fs.readFileSync(path.join(m.VAULT_CONCEPTS_DIR,files2[0]),"utf8");
+console.log("hasFrontmatter="+sample.includes("source: qualia-framework/knowledge-flush"));
+' 2>&1)
+assert_contains "dual-write mirrors concepts (vault-mirrored)" "$OUT" "detail=vault-mirrored"
+assert_contains "dual-write wrote 2 files" "$OUT" "written=2"
+assert_contains "dual-write is idempotent" "$OUT" "idempotent=true"
+assert_contains "dual-write emits a concept-prefixed subdir file" "$OUT" "concept-voice-call-state.md"
+assert_contains "dual-write emits curated top-level file" "$OUT" "learned-patterns.md"
+assert_contains "dual-write stamps provenance front-matter" "$OUT" "hasFrontmatter=true"
+rm -rf "$TMP"
+
+# --- vault absent → graceful skip, no crash ---
+TMP=$(mktemp -d)
+OUT=$(QUALIA_HOME="$TMP/home" QUALIA_MEMORY="$TMP/does-not-exist" $NODE -e '
+const fs=require("fs"),path=require("path");
+const kh=process.env.QUALIA_HOME;
+fs.mkdirSync(path.join(kh,"knowledge"),{recursive:true});
+fs.writeFileSync(path.join(kh,"knowledge","learned-patterns.md"),"# P\n- x\n");
+const m=require("'"$FLUSH"'");
+const r=m.dualWriteVault();
+console.log("detail="+r.event_detail+" written="+r.written);
+' 2>&1)
+assert_ok "vault-absent does not crash" $?
+assert_contains "vault-absent is skipped gracefully" "$OUT" "detail=vault-absent"
+rm -rf "$TMP"
+
+# ── ITEM 14b: freshness gates ───────────────────────────────────────────────
+# Healthy loop: fresh daily-log, recent flush log, fresh export with matching
+# coverage and no deprecated rows → all PASS.
+TMP=$(mktemp -d)
+KH="$TMP/home"; VAULT="$TMP/vault"
+mkdir -p "$KH/knowledge/daily-log"
+TODAY=$(date +%Y-%m-%d)
+echo "# log" > "$KH/knowledge/daily-log/$TODAY.md"
+printf '{"timestamp":"%s","event":"ok"}\n' "$(date -Iseconds)" > "$KH/.qualia-flush.log"
+mkdir -p "$VAULT/wiki/sessions/concepts" "$VAULT/wiki/_export/concepts"
+echo "# c1" > "$VAULT/wiki/sessions/concepts/c1.md"
+echo "# c1 exported" > "$VAULT/wiki/_export/concepts/c1.md"
+OUT=$(QUALIA_HOME="$KH" QUALIA_MEMORY="$VAULT" $NODE "$DOCTOR" --json 2>&1)
+assert_contains "healthy daily-log → PASS" "$OUT" '"gate": "daily-log freshness"'
+HEALTHY_FAILS=$(echo "$OUT" | grep -c '"status": "FAIL"')
+if [ "$HEALTHY_FAILS" -eq 0 ]; then echo "  ✓ healthy loop has zero FAIL gates"; PASS=$((PASS+1)); else echo "  ✗ healthy loop has $HEALTHY_FAILS FAIL gate(s): $OUT"; FAIL=$((FAIL+1)); fi
+rm -rf "$TMP"
+
+# Broken loop: no daily-log, no flush log, no export → FAILs + --exit-code 1.
+TMP=$(mktemp -d)
+mkdir -p "$TMP/home/knowledge" "$TMP/vault"
+OUT=$(QUALIA_HOME="$TMP/home" QUALIA_MEMORY="$TMP/vault" $NODE "$DOCTOR" --json 2>&1)
+assert_contains "broken loop flags stale daily-log" "$OUT" 'no daily-log entries'
+assert_contains "broken loop flags missing flush log" "$OUT" 'flush never ran'
+assert_contains "broken loop flags missing export" "$OUT" 'export never ran'
+QUALIA_HOME="$TMP/home" QUALIA_MEMORY="$TMP/vault" $NODE "$DOCTOR" --exit-code >/dev/null 2>&1
+RC=$?
+if [ "$RC" -eq 1 ]; then echo "  ✓ broken loop --exit-code returns 1"; PASS=$((PASS+1)); else echo "  ✗ broken loop --exit-code returned $RC"; FAIL=$((FAIL+1)); fi
+rm -rf "$TMP"
+
+# Coverage gate: source has 2 concepts, export has 1 → FAIL (stale/partial).
+TMP=$(mktemp -d)
+KH="$TMP/home"; VAULT="$TMP/vault"
+mkdir -p "$KH/knowledge/daily-log"
+echo "# log" > "$KH/knowledge/daily-log/$(date +%Y-%m-%d).md"
+printf '{"timestamp":"%s","event":"ok"}\n' "$(date -Iseconds)" > "$KH/.qualia-flush.log"
+mkdir -p "$VAULT/wiki/sessions/concepts" "$VAULT/wiki/_export/concepts"
+echo "# a" > "$VAULT/wiki/sessions/concepts/a.md"
+echo "# b" > "$VAULT/wiki/sessions/concepts/b.md"
+echo "# a" > "$VAULT/wiki/_export/concepts/a.md"
+OUT=$(QUALIA_HOME="$KH" QUALIA_MEMORY="$VAULT" $NODE "$DOCTOR" --json 2>&1)
+assert_contains "partial export → coverage FAIL" "$OUT" 'export is stale or partial'
+rm -rf "$TMP"
+
+# Deprecated gate: an export file tagged deprecated → FAIL.
+TMP=$(mktemp -d)
+KH="$TMP/home"; VAULT="$TMP/vault"
+mkdir -p "$KH/knowledge/daily-log" "$VAULT/wiki/_export"
+echo "# log" > "$KH/knowledge/daily-log/$(date +%Y-%m-%d).md"
+printf '{"timestamp":"%s","event":"ok"}\n' "$(date -Iseconds)" > "$KH/.qualia-flush.log"
+printf -- '---\ntags: [deprecated, old]\n---\n# stale\n' > "$VAULT/wiki/_export/old.md"
+OUT=$(QUALIA_HOME="$KH" QUALIA_MEMORY="$VAULT" $NODE "$DOCTOR" --json 2>&1)
+assert_contains "deprecated row in export → FAIL" "$OUT" 'deprecated file(s)'
+rm -rf "$TMP"
+
+echo ""
+echo "=== Results: $PASS passed, $FAIL failed ==="
+[ "$FAIL" -eq 0 ] && exit 0 || exit 1