qualia-framework 6.2.9 → 6.3.0

package/bin/cli.js

@@ -5,6 +5,7 @@ const path = require("path");
 const fs = require("fs");
 const readline = require("readline");
 const os = require("os");
+const { binFiles } = require("./runtime-manifest.js");
 
 const TEAL = "\x1b[38;2;0;206;209m";
 const TG = "\x1b[38;2;0;170;175m";
@@ -204,6 +205,7 @@ const QUALIA_HOOK_FILES = [
   "pre-deploy-gate.js",
   "git-guardrails.js",
   "stop-session-log.js",
+  "fawzi-approval-guard.js",
   "env-empty-guard.js",
   "supabase-destructive-guard.js",
   "vercel-account-guard.js",
@@ -228,25 +230,13 @@ const QUALIA_AGENT_FILES = [
 const QUALIA_CODEX_AGENT_FILES = QUALIA_AGENT_FILES.map((f) => f.replace(/\.md$/, ".toml"));
 
 // Qualia bin scripts.
-const QUALIA_BIN_FILES = [
-  "state.js",
-  "qualia-ui.js",
-  "statusline.js",
-  "knowledge.js",
-  "knowledge-flush.js",
-  "plan-contract.js",
-  "agent-runs.js",
-  "slop-detect.mjs",
-  "erp-retry.js",
-  "report-payload.js",
-  "project-snapshot.js",
-];
+const QUALIA_BIN_FILES = binFiles();
 
 // Qualia rules — security, deployment, infra, grounding, plus the v4.5.0 design substrate.
 // frontend.md and design-reference.md are kept for backward compat; new projects use design-laws/brand/product/rubric.
 const QUALIA_RULE_FILES = [
   "security.md", "deployment.md", "infrastructure.md", "grounding.md",
-  "speed.md", "architecture.md", "trust-boundary.md", "one-opinion.md",
+  "speed.md", "architecture.md", "trust-boundary.md", "codex-goal.md", "one-opinion.md", "command-output.md",
   "frontend.md", "design-reference.md",
   "design-laws.md", "design-brand.md", "design-product.md", "design-rubric.md",
 ];
@@ -510,7 +500,7 @@ async function cmdUninstall() {
 
 function getDefaultTeam() {
   return {
-    "QS-FAWZI-01": { name: "Fawzi Goussous", role: "OWNER", description: "Company owner. Full access. Can push to main, approve deploys, edit secrets." },
+    "QS-FAWZI-11": { name: "Fawzi Goussous", role: "OWNER", description: "Company owner. Full access. Can push to main, approve deploys, edit secrets." },
     "QS-HASAN-02": { name: "Hasan", role: "EMPLOYEE", description: "Developer. Feature branches only. Cannot push to main or edit .env files." },
     "QS-MOAYAD-03": { name: "Moayad", role: "EMPLOYEE", description: "Developer. Feature branches only. Cannot push to main or edit .env files." },
     "QS-RAMA-04": { name: "Rama", role: "EMPLOYEE", description: "Developer. Feature branches only. Cannot push to main or edit .env files." },
@@ -1217,6 +1207,74 @@ function cmdProjectSnapshot() {
   process.exit(typeof r.status === "number" ? r.status : 1);
 }
 
+function cmdWorkPacket() {
+  const installedScript = path.join(primaryInstallHome(), "bin", "work-packet.js");
+  const localScript = path.join(__dirname, "work-packet.js");
+  const script = fs.existsSync(installedScript) ? installedScript : localScript;
+  if (!fs.existsSync(script)) {
+    console.log(`  ${RED}✗${RESET} work-packet.js not available`);
+    console.log(`  ${DIM}Run: npx qualia-framework@latest install${RESET}`);
+    process.exit(1);
+  }
+  const args = process.argv.slice(3);
+  const r = spawnSync(process.execPath, [script, ...args], {
+    stdio: "inherit",
+    shell: false,
+  });
+  process.exit(typeof r.status === "number" ? r.status : 1);
+}
+
+function cmdPlanningHygiene() {
+  const installedScript = path.join(primaryInstallHome(), "bin", "planning-hygiene.js");
+  const localScript = path.join(__dirname, "planning-hygiene.js");
+  const script = fs.existsSync(installedScript) ? installedScript : localScript;
+  if (!fs.existsSync(script)) {
+    console.log(`  ${RED}✗${RESET} planning-hygiene.js not available`);
+    console.log(`  ${DIM}Run: npx qualia-framework@latest install${RESET}`);
+    process.exit(1);
+  }
+  const args = process.argv.slice(3);
+  const r = spawnSync(process.execPath, [script, ...args], {
+    stdio: "inherit",
+    shell: false,
+  });
+  process.exit(typeof r.status === "number" ? r.status : 1);
+}
+
+function cmdTrust() {
+  const trustScript = path.join(primaryInstallHome(), "bin", "trust-score.js");
+  const localTrustScript = path.join(__dirname, "trust-score.js");
+  const script = fs.existsSync(trustScript) ? trustScript : localTrustScript;
+  if (!fs.existsSync(script)) {
+    console.log(`  ${RED}✗${RESET} trust-score.js not available`);
+    console.log(`  ${DIM}Run: npx qualia-framework@latest install${RESET}`);
+    process.exit(1);
+  }
+  const args = process.argv.slice(3);
+  const r = spawnSync(process.execPath, [script, ...args], {
+    stdio: "inherit",
+    shell: false,
+  });
+  process.exit(typeof r.status === "number" ? r.status : 1);
+}
+
+function cmdHarnessEval() {
+  const installedScript = path.join(primaryInstallHome(), "bin", "harness-eval.js");
+  const localScript = path.join(__dirname, "harness-eval.js");
+  const script = fs.existsSync(installedScript) ? installedScript : localScript;
+  if (!fs.existsSync(script)) {
+    console.log(`  ${RED}✗${RESET} harness-eval.js not available`);
+    console.log(`  ${DIM}Run: npx qualia-framework@latest install${RESET}`);
+    process.exit(1);
+  }
+  const args = process.argv.slice(3);
+  const r = spawnSync(process.execPath, [script, ...args], {
+    stdio: "inherit",
+    shell: false,
+  });
+  process.exit(typeof r.status === "number" ? r.status : 1);
+}
+
 function cmdFlush() {
   const flushScript = path.join(primaryInstallHome(), "bin", "knowledge-flush.js");
   if (!fs.existsSync(flushScript)) {
@@ -1255,14 +1313,22 @@ function cmdDoctor() {
       "rules/grounding.md",
       "rules/security.md",
       "rules/deployment.md",
+      "rules/command-output.md",
       "bin/state.js",
       "bin/qualia-ui.js",
       "bin/statusline.js",
+      "bin/command-surface.js",
       "bin/knowledge.js",
       "bin/knowledge-flush.js",
+      "bin/state-ledger.js",
+      "bin/plan-contract.js",
+      "bin/contract-runner.js",
+      "bin/trust-score.js",
+      "bin/harness-eval.js",
       "bin/erp-retry.js",
       "bin/report-payload.js",
       "bin/project-snapshot.js",
+      "bin/planning-hygiene.js",
       "knowledge/agents.md",
       "knowledge/index.md",
       "knowledge/daily-log",
@@ -1309,6 +1375,23 @@ function cmdDoctor() {
         check("Codex hooks.json parseable", false, e.message);
       }
     }
+    if (label === "Codex" && fs.existsSync(path.join(home, "config.toml"))) {
+      try {
+        const configToml = fs.readFileSync(path.join(home, "config.toml"), "utf8");
+        const hasTui = /^\[tui\]\s*$/m.test(configToml);
+        const hasStatusLine = /^\s*status_line\s*=\s*\[/m.test(configToml);
+        const hasCoreSegments = [
+          "model-with-reasoning",
+          "task-progress",
+          "current-dir",
+          "git-branch",
+          "context-used",
+        ].every((segment) => configToml.includes(`"${segment}"`));
+        check("Codex config.toml TUI status_line", hasTui && hasStatusLine && hasCoreSegments, "reinstall to wire Codex bottom status line");
+      } catch (e) {
+        check("Codex config.toml status_line parseable", false, e.message);
+      }
+    }
   }
 
   // ── Version vs. installed ──────────────────────────────
@@ -1319,11 +1402,51 @@ function cmdDoctor() {
     check("config has install metadata", false, "reinstall to record");
   }
 
+  // ── Project contract health (advisory, not install-failing) ─────────
+  const projectAdvisories = [];
+  try {
+    const statePath = path.join(process.cwd(), ".planning", "STATE.md");
+    if (fs.existsSync(statePath)) {
+      const stateText = fs.readFileSync(statePath, "utf8");
+      const phaseMatch = stateText.match(/^Phase:\s*(\d+)/m);
+      const phase = phaseMatch ? Number(phaseMatch[1]) : 1;
+      const planPath = path.join(process.cwd(), ".planning", `phase-${phase}-plan.md`);
+      const contractPath = path.join(process.cwd(), ".planning", `phase-${phase}-contract.json`);
+      if (fs.existsSync(planPath)) {
+        if (!fs.existsSync(contractPath)) {
+          projectAdvisories.push(`phase ${phase}: JSON contract missing (degraded trust)`);
+        } else {
+          const pc = require("./plan-contract.js");
+          const loaded = pc.readContractFile(contractPath);
+          if (!loaded.ok) {
+            projectAdvisories.push(`phase ${phase}: JSON contract unreadable (${loaded.message || loaded.error})`);
+          } else {
+            const errs = pc.validate(loaded.contract);
+            const drift = pc.checkDrift(contractPath, planPath);
+            if (errs.length > 0) projectAdvisories.push(`phase ${phase}: JSON contract invalid (${errs.length} issue(s))`);
+            else if (drift.ok && drift.drift) projectAdvisories.push(`phase ${phase}: JSON contract drifted from plan`);
+            else projectAdvisories.push(`phase ${phase}: JSON contract valid`);
+          }
+        }
+      }
+    }
+  } catch (e) {
+    projectAdvisories.push(`project contract health unavailable: ${e.message}`);
+  }
+
   // ── Render ────────────────────────────────────────────
   for (const c of checks) {
     const mark = c.ok ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
     console.log(`  ${mark} ${c.label}`);
   }
+  if (projectAdvisories.length > 0) {
+    console.log("");
+    console.log(`  ${WHITE}Project trust:${RESET}`);
+    for (const item of projectAdvisories) {
+      const mark = item.includes("valid") && !item.includes("invalid") ? `${GREEN}✓${RESET}` : `${YELLOW}!${RESET}`;
+      console.log(`  ${mark} ${item}`);
+    }
+  }
   console.log("");
   if (issues.length === 0) {
     console.log(`  ${GREEN}All checks passed. Framework is healthy.${RESET}`);
@@ -1432,18 +1555,23 @@ function cmdHelp() {
   console.log(`    qualia-framework ${TEAL}set-erp-key${RESET}  Save/enable the ERP API key`);
   console.log(`    qualia-framework ${TEAL}erp-ping${RESET}     Verify ERP connectivity + API key`);
   console.log(`    qualia-framework ${TEAL}erp-flush${RESET}    Retry queued ERP report uploads (${DIM}show|clear${RESET})`);
+  console.log(`    qualia-framework ${TEAL}work-packet${RESET}  Pull/read ERP mission packet (${DIM}pull --project UUID${RESET})`);
   console.log(`    qualia-framework ${TEAL}project-snapshot${RESET} Export/upload ERP admin project progress snapshot (${DIM}--write|--upload${RESET})`);
+  console.log(`    qualia-framework ${TEAL}planning-hygiene${RESET} Scan/organize .planning artifacts (${DIM}scan|organize --write${RESET})`);
   console.log(`    qualia-framework ${TEAL}doctor${RESET}       Health-check the install (files, hooks, settings)`);
+  console.log(`    qualia-framework ${TEAL}trust${RESET}        Score install, state, contracts, memory, ERP (${DIM}--json${RESET})`);
+  console.log(`    qualia-framework ${TEAL}eval${RESET}         Write/run project harness eval scoring (${DIM}--run --write --json${RESET})`);
   console.log(`    qualia-framework ${TEAL}flush${RESET}        Promote daily-log → curated knowledge (memory layer)`);
   console.log("");
   console.log(`  ${WHITE}After install:${RESET}`);
   console.log(`    ${TG}/qualia${RESET}          What should I do next?`);
+  console.log(`    ${TG}/qualia-doctor${RESET}   Health-check install, state, contracts, memory, ERP`);
   console.log(`    ${TG}/qualia-new${RESET}      Set up a new project`);
   console.log(`    ${TG}/qualia-plan${RESET}     Plan a phase`);
   console.log(`    ${TG}/qualia-build${RESET}    Build it (parallel tasks)`);
   console.log(`    ${TG}/qualia-verify${RESET}   Verify it works`);
   console.log(`    ${TG}/qualia-polish${RESET}   Design pass — any scope (component, route, app, redesign)`);
-  console.log(`    ${TG}/qualia-debug${RESET}    Structured debugging`);
+  console.log(`    ${TG}/qualia-fix${RESET}      Root-cause broken behavior, patch, verify`);
   console.log(`    ${TG}/qualia-review${RESET}   Production audit`);
   console.log(`    ${TG}/qualia-ship${RESET}     Deploy to production`);
   console.log(`    ${TG}/qualia-report${RESET}   Log your work`);
@@ -1506,11 +1634,27 @@ switch (cmd) {
   case "snapshot":
     cmdProjectSnapshot();
     break;
+  case "work-packet":
+  case "packet":
+    cmdWorkPacket();
+    break;
+  case "planning-hygiene":
+  case "planning":
+    cmdPlanningHygiene();
+    break;
   case "doctor":
   case "health":
   case "health-check":
     cmdDoctor();
     break;
+  case "trust":
+  case "score":
+    cmdTrust();
+    break;
+  case "eval":
+  case "harness-eval":
+    cmdHarnessEval();
+    break;
   case "flush":
   case "knowledge-flush":
     cmdFlush();

package/bin/command-surface.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Canonical Qualia command surface.
+//
+// The repo may keep retired skills for migration/history, but installs should
+// expose the small active surface below. This gives users fewer commands while
+// preserving compatibility cleanup for older installs.
+
+const ACTIVE_SKILLS = [
+  "qualia",
+  "qualia-new",
+  "qualia-discuss",
+  "qualia-map",
+  "qualia-research",
+  "qualia-plan",
+  "qualia-build",
+  "qualia-verify",
+  "qualia-fix",
+  "qualia-feature",
+  "qualia-review",
+  "qualia-optimize",
+  "qualia-polish",
+  "qualia-test",
+  "qualia-milestone",
+  "qualia-ship",
+  "qualia-handoff",
+  "qualia-report",
+  "qualia-doctor",
+  "qualia-road",
+  "qualia-learn",
+  "qualia-postmortem",
+  "zoho-workflow",
+];
+
+const RETIRED_SKILLS = [
+  // Historical folds.
+  "qualia-task",
+  "qualia-quick",
+  "qualia-polish-loop",
+  "qualia-design",
+  "qualia-prd",
+
+  // v6.3 surface reduction: keep the behavior under sharper active commands.
+  "qualia-debug",      // folded into qualia-fix for actionable repairs
+  "qualia-vibe",       // folded into qualia-polish modes/documentation
+  "qualia-help",       // guide/help files remain installed; no slash command
+  "qualia-idk",        // folded into qualia router diagnostic branch
+  "qualia-pause",      // folded into qualia router handoff branch
+  "qualia-resume",     // folded into qualia router handoff branch
+  "qualia-zoom",       // folded into qualia-map/qualia-review as an analysis mode
+  "qualia-issues",     // GitHub queue externalization is not default workflow
+  "qualia-triage",     // GitHub queue routing is not default workflow
+  "qualia-hook-gen",   // framework-authoring utility, not employee default
+  "qualia-skill-new",  // framework-authoring utility, not employee default
+  "qualia-flush",      // available as qualia-framework flush / automation
+];
+
+function activeSkills() {
+  return [...ACTIVE_SKILLS];
+}
+
+function retiredSkills() {
+  return [...RETIRED_SKILLS];
+}
+
+module.exports = {
+  ACTIVE_SKILLS,
+  RETIRED_SKILLS,
+  activeSkills,
+  retiredSkills,
+};
+

package/bin/contract-runner.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+// Execute Qualia phase contract checks and write evidence.
+// No shell interpolation: command checks run through spawnSync(argv).
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const pc = require("./plan-contract.js");
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") args.json = true;
+    else if (a === "--no-write") args.no_write = true;
+    else if (a === "--cwd") args.cwd = argv[++i];
+    else if (a.startsWith("--cwd=")) args.cwd = a.slice("--cwd=".length);
+    else args._.push(a);
+  }
+  return args;
+}
+
+function usage() {
+  console.error([
+    "Usage:",
+    "  contract-runner.js <contract.json> [--cwd DIR] [--json] [--no-write]",
+    "",
+    "Runs file-exists, grep-match, command-exit, and behavioral evidence checks.",
+  ].join("\n"));
+}
+
+function rel(root, p) {
+  return path.resolve(root, p);
+}
+
+function checkFileExists(root, check) {
+  const file = rel(root, check.path);
+  if (!fs.existsSync(file)) return { ok: false, detail: `missing file: ${check.path}` };
+  if (check.must_contain != null) {
+    const content = fs.readFileSync(file, "utf8");
+    if (!content.includes(check.must_contain)) {
+      return { ok: false, detail: `file does not contain required text: ${check.path}` };
+    }
+  }
+  return { ok: true };
+}
+
+function checkGrepMatch(root, check) {
+  const file = rel(root, check.path);
+  if (!fs.existsSync(file)) return { ok: false, detail: `missing file: ${check.path}` };
+  const content = fs.readFileSync(file, "utf8");
+  const re = new RegExp(check.pattern);
+  const present = re.test(content);
+  if (check.expect === "present" && !present) return { ok: false, detail: `pattern absent: ${check.pattern}` };
+  if (check.expect === "absent" && present) return { ok: false, detail: `pattern present: ${check.pattern}` };
+  return { ok: true };
+}
+
+function checkCommandExit(root, check) {
+  const started = Date.now();
+  const r = spawnSync(check.command, check.args || [], {
+    cwd: root,
+    encoding: "utf8",
+    timeout: check.timeout_ms || 30_000,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false,
+  });
+  const status = typeof r.status === "number" ? r.status : 1;
+  if (status !== check.expected_exit) {
+    return {
+      ok: false,
+      detail: `exit ${status}, expected ${check.expected_exit}`,
+      duration_ms: Date.now() - started,
+      stdout: (r.stdout || "").slice(-1000),
+      stderr: (r.stderr || r.error?.message || "").slice(-1000),
+    };
+  }
+  if (check.expect_stdout_match != null) {
+    const re = new RegExp(check.expect_stdout_match);
+    if (!re.test(r.stdout || "")) {
+      return {
+        ok: false,
+        detail: `stdout did not match: ${check.expect_stdout_match}`,
+        duration_ms: Date.now() - started,
+        stdout: (r.stdout || "").slice(-1000),
+        stderr: (r.stderr || "").slice(-1000),
+      };
+    }
+  }
+  return {
+    ok: true,
+    duration_ms: Date.now() - started,
+    stdout: (r.stdout || "").slice(-1000),
+    stderr: (r.stderr || "").slice(-1000),
+  };
+}
+
+function checkBehavioral(root, check) {
+  for (const ev of check.evidence_required || []) {
+    const file = rel(root, ev.path);
+    if (!fs.existsSync(file)) {
+      return { ok: false, detail: `missing evidence file: ${ev.path}` };
+    }
+    if (ev.matcher != null) {
+      const content = fs.readFileSync(file, "utf8");
+      const re = new RegExp(ev.matcher);
+      if (!re.test(content)) {
+        return { ok: false, detail: `evidence matcher failed for ${ev.path}: ${ev.matcher}` };
+      }
+    }
+  }
+  return { ok: true };
+}
+
+function runCheck(root, check) {
+  try {
+    if (check.type === "file-exists") return checkFileExists(root, check);
+    if (check.type === "grep-match") return checkGrepMatch(root, check);
+    if (check.type === "command-exit") return checkCommandExit(root, check);
+    if (check.type === "behavioral") return checkBehavioral(root, check);
+    return { ok: false, detail: `unknown check type: ${check.type}` };
+  } catch (e) {
+    return { ok: false, detail: e.message };
+  }
+}
+
+function writeEvidence(root, contract, result) {
+  const dir = path.join(root, ".planning", "evidence");
+  fs.mkdirSync(dir, { recursive: true });
+  const phase = Number(contract.phase || 0) || "unknown";
+  const file = path.join(dir, `phase-${phase}-contract-run.json`);
+  fs.writeFileSync(file, JSON.stringify(result, null, 2) + "\n");
+  return path.relative(root, file);
+}
+
+function runContract(contract, opts = {}) {
+  const root = path.resolve(opts.cwd || process.cwd());
+  const errors = pc.validate(contract);
+  if (errors.length > 0) {
+    return {
+      ok: false,
+      error: "CONTRACT_INVALID",
+      errors,
+      checked: 0,
+      failed: errors.length,
+      results: [],
+    };
+  }
+
+  const results = [];
+  for (const task of contract.tasks || []) {
+    for (let i = 0; i < (task.verification || []).length; i++) {
+      const check = task.verification[i];
+      const r = runCheck(root, check);
+      results.push({
+        task_id: task.id,
+        task_title: task.title,
+        index: i,
+        type: check.type,
+        ok: !!r.ok,
+        detail: r.detail || "",
+        duration_ms: r.duration_ms,
+        stdout: r.stdout,
+        stderr: r.stderr,
+      });
+    }
+  }
+  const failed = results.filter((r) => !r.ok).length;
+  const payload = {
+    ok: failed === 0,
+    phase: contract.phase,
+    goal: contract.goal,
+    checked: results.length,
+    failed,
+    generated_at: new Date().toISOString(),
+    results,
+  };
+  if (!opts.no_write) payload.evidence_file = writeEvidence(root, contract, payload);
+  return payload;
+}
+
+function main(argv) {
+  const args = parseArgs(argv);
+  const contractPath = args._[0];
+  if (!contractPath || contractPath === "--help" || contractPath === "-h") {
+    usage();
+    return 2;
+  }
+  const loaded = pc.readContractFile(contractPath);
+  if (!loaded.ok) {
+    const payload = { ok: false, ...loaded, path: contractPath };
+    if (args.json) console.log(JSON.stringify(payload, null, 2));
+    else console.error(`${payload.error}: ${payload.message}`);
+    return 2;
+  }
+  const result = runContract(loaded.contract, {
+    cwd: args.cwd,
+    no_write: args.no_write,
+  });
+  if (args.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.ok) {
+    console.log(`PASS phase ${result.phase}: ${result.checked} check(s)`);
+    if (result.evidence_file) console.log(`Evidence: ${result.evidence_file}`);
+  } else {
+    console.error(`FAIL phase ${result.phase || "?"}: ${result.failed} of ${result.checked || result.failed} check(s) failed`);
+    for (const r of result.results || []) {
+      if (!r.ok) console.error(`- ${r.task_id} ${r.type}: ${r.detail}`);
+    }
+    if (result.error) for (const e of result.errors || []) console.error(`- ${e}`);
+  }
+  return result.ok ? 0 : 1;
+}
+
+module.exports = { runContract, runCheck };
+
+if (require.main === module) {
+  process.exit(main(process.argv));
+}