qualia-framework 6.2.10 → 6.4.0

package/bin/learning-candidates.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+// bin/learning-candidates.js — scan recent git history + daily-log for
+// repeated patterns and emit a list of skill-creation candidates.
+//
+// Run via:
+//   qualia-framework learn-scan           # writes ~/.claude/knowledge/learning-candidates.md
+//   qualia-framework learn-scan --print    # also prints to stdout
+//   qualia-framework learn-scan --since=7  # look at last 7 days (default: 14)
+//
+// What it detects:
+//   1. Repeated fix-scope patterns — "fix(auth):" appearing 3+ times in 14 days
+//      → suggest a skill or hook that prevents/diagnoses that class of bug.
+//   2. Repeated touched-file patterns — same file appearing in 4+ session
+//      checkpoints → suggest factoring or codifying the workflow around it.
+//   3. Repeated phrases in daily-log entries — heuristic, low-signal v1.
+//
+// What it does NOT do:
+//   - Auto-create skills. That's /qualia-skill-new's job (with human review).
+//   - Touch the wiki tier (knowledge/concepts/). That's /qualia-flush's job.
+//   - Run continuously in background. ECC's Haiku observer is over-engineered
+//     for Qualia's weekly cadence. Run this manually or via /qualia-flush.
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawnSync } = require("child_process");
+
+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(os.homedir(), ".claude");
+}
+
+function git(args, opts = {}) {
+  try {
+    const r = spawnSync("git", args, { encoding: "utf8", timeout: 3000, shell: process.platform === "win32", ...opts });
+    if (r.status !== 0) return "";
+    return (r.stdout || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+function parseArgs(argv) {
+  const args = { print: false, sinceDays: 14 };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--print") args.print = true;
+    else if (a.startsWith("--since=")) {
+      const n = parseInt(a.split("=")[1], 10);
+      if (n > 0) args.sinceDays = n;
+    } else if (a === "--since" && argv[i + 1]) {
+      const n = parseInt(argv[++i], 10);
+      if (n > 0) args.sinceDays = n;
+    }
+  }
+  return args;
+}
+
+// Conventional Commits subject parser. Returns {type, scope} or null.
+function parseCommitSubject(subject) {
+  const m = subject.match(/^([a-z]+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/i);
+  if (!m) return null;
+  return { type: m[1].toLowerCase(), scope: m[2] || "", description: m[4] };
+}
+
+function scanRepoCommits(repoRoot, sinceDays) {
+  const out = git(["log", `--since=${sinceDays}.days`, "--pretty=%H%x09%s"], { cwd: repoRoot });
+  if (!out) return [];
+  const commits = [];
+  for (const line of out.split("\n")) {
+    const [sha, subject] = line.split("\t");
+    if (!sha || !subject) continue;
+    const parsed = parseCommitSubject(subject);
+    if (parsed) commits.push({ sha, subject, ...parsed });
+  }
+  return commits;
+}
+
+function aggregateFixPatterns(commits) {
+  // Group fix-type commits by scope (or by first-word of description if no scope).
+  const groups = new Map();
+  for (const c of commits) {
+    if (c.type !== "fix") continue;
+    const key = c.scope || c.description.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "");
+    if (!key) continue;
+    const arr = groups.get(key) || [];
+    arr.push(c);
+    groups.set(key, arr);
+  }
+  return [...groups.entries()]
+    .filter(([, arr]) => arr.length >= 3)
+    .sort((a, b) => b[1].length - a[1].length)
+    .map(([scope, arr]) => ({ scope, count: arr.length, samples: arr.slice(0, 3).map((c) => `${c.sha.slice(0, 7)} ${c.subject}`) }));
+}
+
+function readDailyLogs(qhome, sinceDays) {
+  const dir = path.join(qhome, "knowledge", "daily-log");
+  if (!fs.existsSync(dir)) return [];
+  const cutoff = Date.now() - sinceDays * 86_400_000;
+  const out = [];
+  for (const f of fs.readdirSync(dir)) {
+    if (!f.endsWith(".md")) continue;
+    const m = f.match(/^(\d{4}-\d{2}-\d{2})\.md$/);
+    if (!m) continue;
+    const date = new Date(m[1] + "T00:00:00Z").getTime();
+    if (date < cutoff) continue;
+    try {
+      out.push({ date: m[1], content: fs.readFileSync(path.join(dir, f), "utf8") });
+    } catch {}
+  }
+  return out;
+}
+
+function aggregateTouchedFiles(dailyLogs) {
+  // Look for "touched=a,b,c" across entries. Count occurrences per file.
+  const counts = new Map();
+  for (const log of dailyLogs) {
+    const matches = log.content.matchAll(/touched=([^\s·]+)/g);
+    for (const m of matches) {
+      for (const f of m[1].split(",")) {
+        const k = f.trim();
+        if (!k) continue;
+        counts.set(k, (counts.get(k) || 0) + 1);
+      }
+    }
+  }
+  return [...counts.entries()]
+    .filter(([, n]) => n >= 4)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([file, count]) => ({ file, count }));
+}
+
+function render({ sinceDays, fixPatterns, touchedFiles, repoRoot }) {
+  const lines = [];
+  lines.push(`# Learning candidates — generated ${new Date().toISOString()}`);
+  lines.push("");
+  lines.push(`Scope: last ${sinceDays} days.`);
+  if (repoRoot) lines.push(`Repo: ${repoRoot}`);
+  lines.push("");
+  lines.push("Each candidate below is a pattern that recurred enough times to be worth promoting into a skill, agent, or hook. Review and act:");
+  lines.push("- `/qualia-skill-new` — create a Qualia skill for the workflow");
+  lines.push("- `/qualia-hook-gen` — convert a CLAUDE.md instruction into a deterministic hook");
+  lines.push("- `/qualia-learn` — save a one-off learning to the knowledge wiki");
+  lines.push("- Ignore — patterns that aren't worth automating");
+  lines.push("");
+
+  lines.push("## Repeated fix-scopes (Conventional Commits)");
+  if (fixPatterns.length === 0) {
+    lines.push("(none — no scope has 3+ fixes in the window)");
+  } else {
+    for (const fp of fixPatterns) {
+      lines.push(`### \`fix(${fp.scope})\` — ${fp.count} commits`);
+      lines.push("Recent samples:");
+      for (const s of fp.samples) lines.push(`- ${s}`);
+      lines.push("");
+      lines.push(`> **Suggested action:** if this keeps recurring, add a guard hook or a /qualia-skill-new dedicated to debugging \`${fp.scope}\`.`);
+      lines.push("");
+    }
+  }
+
+  lines.push("## Repeatedly-touched files");
+  if (touchedFiles.length === 0) {
+    lines.push("(none — no file appeared in 4+ session checkpoints)");
+  } else {
+    lines.push("File | Touched count");
+    lines.push("---|---:");
+    for (const t of touchedFiles) lines.push(`\`${t.file}\` | ${t.count}`);
+    lines.push("");
+    lines.push("> **Suggested action:** files touched this often may be a hotspot (deserves more tests) or a friction point (deserves a skill that automates the recurring edit).");
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("_Generated by `bin/learning-candidates.js`. Re-run with `qualia-framework learn-scan` or `qualia-framework learn-scan --since=30`._");
+
+  return lines.join("\n") + "\n";
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const qhome = qualiaHome();
+  const cwd = process.cwd();
+  const repoRoot = git(["rev-parse", "--show-toplevel"], { cwd }) || "";
+
+  const commits = repoRoot ? scanRepoCommits(repoRoot, args.sinceDays) : [];
+  const fixPatterns = aggregateFixPatterns(commits);
+  const dailyLogs = readDailyLogs(qhome, args.sinceDays);
+  const touchedFiles = aggregateTouchedFiles(dailyLogs);
+
+  const doc = render({ sinceDays: args.sinceDays, fixPatterns, touchedFiles, repoRoot });
+
+  const outDir = path.join(qhome, "knowledge");
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+  const outPath = path.join(outDir, "learning-candidates.md");
+  fs.writeFileSync(outPath, doc);
+
+  // Stamp last-scan time.
+  fs.writeFileSync(path.join(qhome, ".qualia-last-learning-scan"), String(Date.now()));
+
+  if (args.print) {
+    process.stdout.write(doc);
+  } else {
+    console.log(`Wrote ${fixPatterns.length} fix-pattern candidate(s) + ${touchedFiles.length} hot file(s) to ${outPath}`);
+  }
+}
+
+module.exports = { main, aggregateFixPatterns, aggregateTouchedFiles, parseCommitSubject };
+
+if (require.main === module) {
+  try { main(); }
+  catch (e) {
+    console.error(`learn-scan failed: ${e.message}`);
+    process.exit(1);
+  }
+}

package/bin/project-snapshot.js

@@ -5,6 +5,8 @@ const https = require("https");
 const os = require("os");
 const path = require("path");
 const { spawnSync } = require("child_process");
+const harnessEval = require("./harness-eval.js");
+const { readLocalWorkPacket } = require("./work-packet.js");
 
 function readJson(file, fallback = {}) {
   try {
@@ -90,6 +92,8 @@ function buildSnapshot(options = {}) {
   const projectId = tracking.project_id || repoSlug(gitRemote) || path.basename(cwd);
   const currentMilestone = Number(tracking.milestone || 1);
   const currentPhase = Number(tracking.phase || 0);
+  const latestHarnessEval = harnessEval.latestEval(cwd);
+  const workPacket = readLocalWorkPacket(cwd);
   const totalPhases = Number(tracking.total_phases || 0);
   const lifetime = tracking.lifetime && typeof tracking.lifetime === "object" ? tracking.lifetime : {};
   const closedMilestones = Array.isArray(tracking.milestones) ? tracking.milestones : [];
@@ -118,6 +122,11 @@ function buildSnapshot(options = {}) {
       ...(uuid(tracking.erp_project_id) ? { erp_project_id: uuid(tracking.erp_project_id) } : {}),
       ...(uuid(tracking.client_id) ? { client_id: uuid(tracking.client_id) } : {}),
       ...(uuid(tracking.workspace_id) ? { workspace_id: uuid(tracking.workspace_id) } : {}),
+      ...(workPacket ? { work_packet_id: workPacket.id } : {}),
+      ...(workPacket && workPacket.assignment_id ? { assignment_id: workPacket.assignment_id } : {}),
+      ...(workPacket && workPacket.deadline_date
+        ? { assignment_deadline: workPacket.deadline_date }
+        : {}),
     },
     project: {
       name: tracking.project || path.basename(cwd),
@@ -137,6 +146,17 @@ function buildSnapshot(options = {}) {
       verification: tracking.verification || "pending",
       gap_cycles: (tracking.gap_cycles || {})[String(currentPhase)] || 0,
     },
+    quality: {
+      harness_eval: latestHarnessEval
+        ? {
+            status: latestHarnessEval.status,
+            score: latestHarnessEval.score,
+            phase: latestHarnessEval.phase,
+            generated_at: latestHarnessEval.generated_at,
+            artifact: latestHarnessEval.artifacts && latestHarnessEval.artifacts.json,
+          }
+        : null,
+    },
     journey: {
       total_milestones: journeyTotal,
       milestones: journey.map((milestone) => ({

package/bin/prune-deprecated.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Shared helper: prune retired skill folders from an install home (~/.claude or ~/.codex).
+//
+// Why a separate file: install.js already runs prune on install, but users often run
+// `qualia-framework doctor` more frequently than they re-install. When a skill is
+// retired (moved from ACTIVE_SKILLS → RETIRED_SKILLS in command-surface.js), the
+// folder must also be removed from the install home, or the harness will keep
+// advertising it as live and users will invoke "trap skills" that no longer route.
+//
+// Both install.js and cli.js (doctor) call this.
+
+const fs = require("fs");
+const path = require("path");
+const { RETIRED_SKILLS } = require("./command-surface.js");
+
+function findGhostSkills(baseDir) {
+  const skillsDir = path.join(baseDir, "skills");
+  if (!fs.existsSync(skillsDir)) return [];
+  return RETIRED_SKILLS.filter((name) => fs.existsSync(path.join(skillsDir, name)));
+}
+
+// Returns { removed: [names], errors: [{name, target, error}] }.
+// Callers can decide how to surface errors — the doctor flow logs them, the
+// install flow shows them as warnings. We do NOT silently swallow them (per
+// CodeRabbit review on PR #46): a permissions / mount-point failure during
+// prune leaves stale ghost skills installed and the user has no signal.
+function pruneGhostSkills(baseDir) {
+  const skillsDir = path.join(baseDir, "skills");
+  if (!fs.existsSync(skillsDir)) return { removed: [], errors: [] };
+  const removed = [];
+  const errors = [];
+  for (const name of RETIRED_SKILLS) {
+    const target = path.join(skillsDir, name);
+    try {
+      if (fs.existsSync(target)) {
+        fs.rmSync(target, { recursive: true, force: true });
+        removed.push(name);
+      }
+    } catch (err) {
+      errors.push({ name, target, error: err && err.message ? err.message : String(err) });
+    }
+  }
+  return { removed, errors };
+}
+
+module.exports = { findGhostSkills, pruneGhostSkills };
+
+if (require.main === module) {
+  // CLI: `node prune-deprecated.js <baseDir>` — useful for manual cleanup.
+  const baseDir = process.argv[2] || path.join(require("os").homedir(), ".claude");
+  const { removed, errors } = pruneGhostSkills(baseDir);
+  if (errors.length > 0) {
+    console.error(`Pruned ${removed.length} ghost skill(s); ${errors.length} failed:`);
+    for (const e of errors) console.error(`  ✗ ${e.name} (${e.target}): ${e.error}`);
+    if (removed.length > 0) for (const name of removed) console.log(`  - ${name}`);
+    process.exit(1);
+  }
+  if (removed.length === 0) {
+    console.log(`No ghost skills in ${baseDir}/skills/`);
+  } else {
+    console.log(`Pruned ${removed.length} ghost skill(s) from ${baseDir}/skills/:`);
+    for (const name of removed) console.log(`  - ${name}`);
+  }
+}

package/bin/report-payload.js

@@ -3,6 +3,8 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const { spawnSync } = require("child_process");
+const harnessEval = require("./harness-eval.js");
+const { readLocalWorkPacket } = require("./work-packet.js");
 
 function readJson(file, fallback = {}) {
   try {
@@ -84,6 +86,8 @@ function buildPayload(options = {}) {
   const gitRemote = tracking.git_remote || git(["config", "--get", "remote.origin.url"], cwd);
   const projectKey = tracking.project_id || repoSlug(gitRemote) || path.basename(cwd);
   const phase = tracking.phase;
+  const latestHarnessEval = harnessEval.latestEval(cwd);
+  const workPacket = readLocalWorkPacket(cwd);
 
   return {
     project: tracking.project || path.basename(cwd),
@@ -93,6 +97,11 @@ function buildPayload(options = {}) {
     ...(uuid(tracking.erp_project_id) ? { erp_project_id: uuid(tracking.erp_project_id) } : {}),
     ...(uuid(tracking.client_id) ? { client_id: uuid(tracking.client_id) } : {}),
     ...(uuid(tracking.workspace_id) ? { workspace_id: uuid(tracking.workspace_id) } : {}),
+    ...(workPacket ? { work_packet_id: workPacket.id } : {}),
+    ...(workPacket && workPacket.assignment_id ? { assignment_id: workPacket.assignment_id } : {}),
+    ...(workPacket && workPacket.deadline_date
+      ? { assignment_deadline: workPacket.deadline_date }
+      : {}),
     client: tracking.client || "",
     client_report_id: env.CLIENT_REPORT_ID || "",
     framework_version: config.version || "",
@@ -114,6 +123,15 @@ function buildPayload(options = {}) {
     ...(tracking.last_pushed_at ? { last_pushed_at: tracking.last_pushed_at } : {}),
     session_duration_minutes: sessionDurationMinutes(tracking.session_started_at, submittedAt),
     lifetime: tracking.lifetime || {},
+    ...(latestHarnessEval ? {
+      harness_eval: {
+        status: latestHarnessEval.status,
+        score: latestHarnessEval.score,
+        phase: latestHarnessEval.phase,
+        generated_at: latestHarnessEval.generated_at,
+        artifact: latestHarnessEval.artifacts && latestHarnessEval.artifacts.json,
+      },
+    } : {}),
     commits: recentCommitHashes(cwd),
     notes,
     submitted_by: env.SUBMITTED_BY || "unknown",

package/bin/runtime-manifest.js

@@ -3,6 +3,7 @@
 
 const RUNTIME_BIN_SCRIPTS = [
   { file: "runtime-manifest.js", label: "runtime-manifest.js (shared install manifest)" },
+  { file: "command-surface.js", label: "command-surface.js (active/deprecated skill manifest)" },
   { file: "host-adapters.js", label: "host-adapters.js (Claude/Codex path renderer)" },
   { file: "state.js", label: "state.js (state machine)" },
   { file: "qualia-ui.js", label: "qualia-ui.js (cosmetics library)" },
@@ -15,11 +16,17 @@ const RUNTIME_BIN_SCRIPTS = [
   { file: "agent-runs.js", label: "agent-runs.js (agent telemetry writer)" },
   { file: "slop-detect.mjs", label: "slop-detect.mjs (anti-pattern scanner — runs pre-commit on frontend builds)" },
   { file: "erp-retry.js", label: "erp-retry.js (ERP report retry queue — drained by session-start hook and erp-flush CLI)" },
+  { file: "work-packet.js", label: "work-packet.js (ERP mission/work packet pull + local reader)" },
   { file: "report-payload.js", label: "report-payload.js (Framework -> ERP report payload builder)" },
   { file: "project-snapshot.js", label: "project-snapshot.js (ERP/admin project progress snapshot)" },
   { file: "trust-score.js", label: "trust-score.js (harness health scoring)" },
+  { file: "harness-eval.js", label: "harness-eval.js (project eval scoring + evidence artifact)" },
   { file: "codex-goal.js", label: "codex-goal.js (Codex /goal objective + token-budget suggester)" },
   { file: "planning-hygiene.js", label: "planning-hygiene.js (.planning organization scanner)" },
+  { file: "prune-deprecated.js", label: "prune-deprecated.js (ghost-skill cleanup for retired commands)" },
+  { 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)" },
 ];
 
 function binFiles() {