novahiz 0.1.0

package/src/catalog.ts

@@ -0,0 +1,266 @@
+import { mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { basename, isAbsolute, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expandHome, type Spec } from "./spec.ts";
+import type { CatalogSkill } from "./relevance.ts";
+
+type SkillRecord = {
+  id: string;
+  name: string;
+  description: string;
+  sourcePath: string;
+  power: number;
+  stars: number | null;
+  tags: string[];
+  categories: string[];
+};
+
+const IGNORED_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", ".cache"]);
+
+function stripQuotes(value: string): string {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+export function parseFrontmatter(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  const text = content.replace(/^\uFEFF/, "");
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return result;
+  let end = -1;
+  for (let index = 1; index < lines.length; index += 1) {
+    if (lines[index].trim() === "---") {
+      end = index;
+      break;
+    }
+  }
+  if (end === -1) return result;
+
+  const block = lines.slice(1, end);
+  for (let index = 0; index < block.length; index += 1) {
+    const line = block[index];
+    const separator = line.indexOf(":");
+    if (separator === -1) continue;
+    const key = line.slice(0, separator).trim();
+    if (key.length === 0) continue;
+    const raw = line.slice(separator + 1).trim();
+    const isBlock = ["|", "|-", "|+", ">", ">-", ">+"].includes(raw);
+    if (isBlock) {
+      const folded = raw.startsWith(">");
+      const parts: string[] = [];
+      while (index + 1 < block.length) {
+        const next = block[index + 1];
+        if (next.trim() === "" || /^\s/.test(next)) {
+          index += 1;
+          parts.push(next.replace(/^\s+/, ""));
+        } else {
+          break;
+        }
+      }
+      result[key] = folded ? parts.join(" ").replace(/\s+/g, " ").trim() : parts.join("\n").trim();
+      continue;
+    }
+    result[key] = stripQuotes(raw);
+  }
+  return result;
+}
+
+function walkForSkillFiles(root: string, found: string[], visited: Set<string>, errors: string[]): void {
+  let real: string;
+  try {
+    real = realpathSync(root);
+  } catch (error) {
+    errors.push(`scan could not resolve ${root}: ${String(error)}`);
+    return;
+  }
+  if (visited.has(real)) return;
+  visited.add(real);
+
+  let entries: string[];
+  try {
+    entries = readdirSync(root).sort();
+  } catch (error) {
+    errors.push(`scan could not list ${root}: ${String(error)}`);
+    return;
+  }
+  for (const entry of entries) {
+    if (IGNORED_DIRECTORIES.has(entry)) continue;
+    const full = join(root, entry);
+    let stats;
+    try {
+      stats = statSync(full);
+    } catch (error) {
+      errors.push(`scan could not stat ${full}: ${String(error)}`);
+      continue;
+    }
+    if (stats.isDirectory()) {
+      walkForSkillFiles(full, found, visited, errors);
+    } else if (entry === "SKILL.md") {
+      found.push(full);
+    }
+  }
+}
+
+export function scanSkills(spec: Spec, errors: string[] = []): SkillRecord[] {
+  const files: string[] = [];
+  const visited = new Set<string>();
+  for (const root of spec.config.skillRoots) {
+    const expanded = expandHome(root);
+    walkForSkillFiles(isAbsolute(expanded) ? expanded : join(spec.root, expanded), files, visited, errors);
+  }
+  files.sort();
+
+  const byId = new Map<string, SkillRecord>();
+  for (const file of files) {
+    let content: string;
+    try {
+      content = readFileSync(file, "utf8");
+    } catch (error) {
+      errors.push(`scan could not read ${file}: ${String(error)}`);
+      continue;
+    }
+    const frontmatter = parseFrontmatter(content);
+    const folder = basename(join(file, ".."));
+    const id = (frontmatter.name || folder).trim();
+    if (id.length === 0) continue;
+    const override = spec.overrides.skills?.[id];
+    const record: SkillRecord = {
+      id,
+      name: frontmatter.name || folder,
+      description: frontmatter.description || "",
+      sourcePath: file,
+      power: override?.power ?? 3,
+      stars: override?.stars ?? null,
+      tags: override?.tags ?? [],
+      categories: override?.categories ?? []
+    };
+    const existing = byId.get(id);
+    const better =
+      !existing ||
+      record.power > existing.power ||
+      (record.power === existing.power && record.sourcePath < existing.sourcePath);
+    if (better) byId.set(id, record);
+  }
+
+  return [...byId.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+export function writeSkillIndex(spec: Spec, skills: SkillRecord[]): string {
+  const directory = join(spec.root, "build");
+  mkdirSync(directory, { recursive: true });
+  const target = join(directory, "installed-skills.json");
+  const ids = skills.map((skill) => skill.id).sort();
+  writeFileSync(target, `${JSON.stringify(ids, null, 2)}\n`, "utf8");
+  return target;
+}
+
+type InstalledIndex = {
+  available: boolean;
+  skills: Set<string>;
+};
+
+export function writeCatalog(spec: Spec, skills: SkillRecord[]): string {
+  const directory = join(spec.root, "build");
+  mkdirSync(directory, { recursive: true });
+  const target = join(directory, "catalog.json");
+  const records = skills.map((skill) => ({
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    power: skill.power,
+    stars: skill.stars,
+    tags: skill.tags,
+    categories: skill.categories
+  }));
+  writeFileSync(target, `${JSON.stringify(records, null, 2)}\n`, "utf8");
+  return target;
+}
+
+export function loadCatalog(spec: Spec): CatalogSkill[] {
+  try {
+    const raw = readFileSync(join(spec.root, "build", "catalog.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? (parsed as CatalogSkill[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function loadInstalledSkills(spec: Spec): InstalledIndex {
+  let raw: string;
+  try {
+    raw = readFileSync(join(spec.root, "build", "installed-skills.json"), "utf8");
+  } catch {
+    return { available: false, skills: new Set() };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return { available: false, skills: new Set() };
+    return { available: true, skills: new Set(parsed.map((value) => String(value))) };
+  } catch {
+    return { available: false, skills: new Set() };
+  }
+}
+
+export function persistCatalog(db: DatabaseSync, spec: Spec, skills: SkillRecord[]): void {
+  const now = new Date().toISOString();
+  db.exec("BEGIN; DELETE FROM skills; DELETE FROM categories; DELETE FROM rules;");
+  try {
+    const upsertSkill = db.prepare(
+      `INSERT INTO skills (id, name, description, source_path, power, stars, tags, categories, scanned_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         description = excluded.description,
+         source_path = excluded.source_path,
+         power = excluded.power,
+         stars = excluded.stars,
+         tags = excluded.tags,
+         categories = excluded.categories,
+         scanned_at = excluded.scanned_at`
+    );
+    for (const skill of skills) {
+      upsertSkill.run(
+        skill.id,
+        skill.name,
+        skill.description,
+        skill.sourcePath,
+        skill.power,
+        skill.stars,
+        JSON.stringify(skill.tags),
+        JSON.stringify(skill.categories),
+        now
+      );
+    }
+
+    const upsertCategory = db.prepare(
+      `INSERT INTO categories (id, label, priority, keywords, default_skills)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         label = excluded.label,
+         priority = excluded.priority,
+         keywords = excluded.keywords,
+         default_skills = excluded.default_skills`
+    );
+    for (const category of spec.categories) {
+      upsertCategory.run(
+        category.id,
+        category.label,
+        category.priority,
+        JSON.stringify(category.keywords),
+        JSON.stringify(category.defaultSkills)
+      );
+    }
+
+    const insertRule = db.prepare("INSERT INTO rules (id, json) VALUES (?, ?)");
+    for (const rule of spec.rules) {
+      insertRule.run(rule.id, JSON.stringify(rule));
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}

package/src/classify.ts

@@ -0,0 +1,201 @@
+import type { Category, CategoryKeyword, RoadmapStep, Spec } from "./spec.ts";
+import { providersForCategories } from "./providers.ts";
+
+type CategoryScore = {
+  id: string;
+  score: number;
+  confidence: number;
+  margin: number;
+  terms: string[];
+  negatives: string[];
+};
+
+type RoadmapView = {
+  category: string;
+  id: string;
+  steps: RoadmapStep[];
+};
+
+type SkillInvocation = {
+  category: string;
+  step: string;
+  label: string;
+  kind: RoadmapStep["kind"];
+  skills: string[];
+  optional: boolean;
+};
+
+type Classification = {
+  categories: CategoryScore[];
+  primary: string | null;
+  requiredSkills: string[];
+  enforcedSkills: string[];
+  invocations: SkillInvocation[];
+  providers: string[];
+  roadmaps: RoadmapView[];
+};
+
+type ClassifyOptions = {
+  minScore?: number;
+  maxCategories?: number;
+  fallbackCategory?: string;
+};
+
+export function fold(value: string): string {
+  return value
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "");
+}
+
+function escapeRegex(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function termMatches(text: string, keyword: string): boolean {
+  const needle = fold(keyword).trim();
+  if (needle.length === 0) return false;
+  const pattern = new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegex(needle)}([^\\p{L}\\p{N}]|$)`, "u");
+  return pattern.test(text);
+}
+
+function keywordTerm(keyword: CategoryKeyword): string {
+  return typeof keyword === "string" ? keyword : keyword.term;
+}
+
+function keywordWeight(keyword: CategoryKeyword): number {
+  if (typeof keyword === "string") return 1;
+  return typeof keyword.weight === "number" ? keyword.weight : 1;
+}
+
+function matchedAlternative(text: string, keyword: CategoryKeyword): string | null {
+  const raw = keywordTerm(keyword);
+  const alternatives = raw.includes("|") ? raw.split("|") : [raw];
+  for (const alternative of alternatives) {
+    const term = alternative.trim();
+    if (term.length > 0 && termMatches(text, term)) return term;
+  }
+  return null;
+}
+
+function byCodeUnit(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function confidence(score: number): number {
+  if (score <= 0) return 0;
+  return Math.round((score / (score + 2)) * 100) / 100;
+}
+
+function skillsOfCategory(category: Category): string[] {
+  const skills: string[] = [...category.defaultSkills];
+  for (const step of category.roadmap?.steps ?? []) {
+    for (const skill of step.requireSkills ?? []) {
+      if (!skills.includes(skill)) skills.push(skill);
+    }
+  }
+  return skills;
+}
+
+function enforcedOfCategory(category: Category): string[] {
+  const skills: string[] = [];
+  for (const step of category.roadmap?.steps ?? []) {
+    if (step.kind !== "skill" || step.optional) continue;
+    for (const skill of step.requireSkills ?? []) {
+      if (!skills.includes(skill)) skills.push(skill);
+    }
+  }
+  return skills;
+}
+
+export function classify(spec: Spec, prompt: string, options: ClassifyOptions = {}): Classification {
+  const minScore = options.minScore ?? spec.config.classify.minScore;
+  const maxCategories = options.maxCategories ?? spec.config.classify.maxCategories;
+  const fallbackCategory = options.fallbackCategory ?? spec.config.classify.fallbackCategory;
+  const text = fold(prompt);
+
+  const scored: CategoryScore[] = [];
+  for (const category of spec.categories) {
+    let score = 0;
+    const terms: string[] = [];
+    const negatives: string[] = [];
+    for (const keyword of category.keywords) {
+      const matched = matchedAlternative(text, keyword);
+      if (!matched) continue;
+      let weight = keywordWeight(keyword);
+      if (matched.includes(" ")) weight += 0.5;
+      score += weight;
+      terms.push(matched);
+    }
+    for (const negative of category.negativeKeywords ?? []) {
+      const matched = matchedAlternative(text, negative);
+      if (!matched) continue;
+      score -= keywordWeight(negative);
+      negatives.push(matched);
+    }
+    if (score >= minScore) {
+      scored.push({ id: category.id, score, confidence: confidence(score), margin: 0, terms, negatives });
+    }
+  }
+
+  const priorityOf = (id: string): number =>
+    spec.categories.find((category) => category.id === id)?.priority ?? 0;
+
+  scored.sort(
+    (a, b) => b.score - a.score || priorityOf(b.id) - priorityOf(a.id) || byCodeUnit(a.id, b.id)
+  );
+
+  for (let index = 0; index < scored.length; index += 1) {
+    const next = scored[index + 1]?.score ?? 0;
+    scored[index].margin = Math.round((scored[index].score - next) * 1000) / 1000;
+  }
+
+  const selected = scored.slice(0, Math.max(0, maxCategories));
+  if (selected.length === 0 && fallbackCategory.length > 0) {
+    selected.push({ id: fallbackCategory, score: 0, confidence: 0, margin: 0, terms: [], negatives: [] });
+  }
+
+  const requiredSkills: string[] = [];
+  const invocations: SkillInvocation[] = [];
+  const roadmaps: RoadmapView[] = [];
+  for (const item of selected) {
+    const category = spec.categories.find((entry) => entry.id === item.id);
+    if (!category) continue;
+    for (const skill of skillsOfCategory(category)) {
+      if (!requiredSkills.includes(skill)) requiredSkills.push(skill);
+    }
+    for (const step of category.roadmap?.steps ?? []) {
+      if (step.kind !== "skill") continue;
+      invocations.push({
+        category: category.id,
+        step: step.id,
+        label: step.label,
+        kind: step.kind,
+        skills: step.requireSkills ?? [],
+        optional: step.optional === true
+      });
+    }
+    if (category.roadmap) {
+      roadmaps.push({ category: category.id, id: category.roadmap.id, steps: category.roadmap.steps });
+    }
+  }
+
+  const primary = selected[0]?.id ?? null;
+  const primaryCategory = primary ? spec.categories.find((entry) => entry.id === primary) : undefined;
+  const enforcedSkills = primaryCategory ? enforcedOfCategory(primaryCategory) : [];
+
+  const providers = providersForCategories(
+    spec,
+    selected.map((entry) => entry.id)
+  ).map((provider) => provider.id);
+
+  return {
+    categories: selected,
+    primary,
+    requiredSkills,
+    enforcedSkills,
+    invocations,
+    providers,
+    roadmaps
+  };
+}

package/src/cli.ts

@@ -0,0 +1,115 @@
+import { resolve } from "node:path";
+import { parse, print } from "./commands/context.ts";
+import { expandHome } from "./spec.ts";
+
+import { commandCheck, commandSync, commandClassify, commandSkills, commandCategories, commandRules, commandSessionLoad, commandSessionState, commandCatalog, commandRoadmap, commandStep, commandProviders, commandDeps, commandDispatch } from "./commands/inspect.ts";
+import { commandGate } from "./commands/gate.ts";
+import { commandReport } from "./commands/report.ts";
+import { commandTask } from "./commands/task.ts";
+import { commandClean } from "./commands/clean.ts";
+import { commandDoctor } from "./commands/doctor.ts";
+import { commandTokens } from "./commands/tokens.ts";
+
+function usage(): void {
+  print({
+    name: "novahiz",
+    commands: [
+      "check",
+      "sync",
+      "classify <text> [--min-score N] [--max-categories N]",
+      "gate --tool <tool> (--file <path> | --args-stdin) [--categories a,b] [--loaded a,b] [--session id]",
+      "skills [--category id]",
+      "categories",
+      "rules",
+      "session-load --session id --skill name",
+      "session-state --session id",
+      "report [--format markdown]",
+      "catalog <query> [--limit N]",
+      "roadmap --category id | <query>",
+      "step --session id --done <step>",
+      "providers [--category id] [--mcp-json] [--install]",
+      "deps [--install]",
+      "task new --title <title> [--id id] [--session id]",
+      "task plan [--task id] [--session id] (JSON array on stdin or --json '<...>')",
+      "task todo --label <label> [--task id] [--kind read|edit|verify|delegate] [--owner a,b] [--acceptance ...] [--max-iterations N]",
+      "task start|done|block --id <todo> [--proof ...|--reason ...]",
+      "task review [--task id] [--reason ...] [--json '<additions|amendments|removals|order>'] (or JSON on stdin)",
+      "task amend --id <todo> [--label ...] [--kind ...] [--acceptance ...] [--owner a,b] [--max-iterations N]",
+      "task insert --label <label> [--task id] [--kind ...] [--owner a,b] [--acceptance ...] [--position start|end|N]",
+      "task drop --id <todo> [--reason ...]",
+      "task reorder [--task id] --order <id,id,...>",
+      "task signals [--task id]",
+      "task status|resume|current [--session id]",
+      "dispatch [--task id] [--session id]",
+      "clean [--target logs|roadmap|sessions|tasks|all] [--days N] [--dry-run|--apply] [--vacuum] [--json]",
+      "doctor [--json]",
+      "tokens [--json] [--calibrate]"
+    ]
+  });}
+
+function main(argv: string[]): void {
+  const parsed = parse(argv);
+  if (typeof parsed.flags.home === "string" && parsed.flags.home.length > 0) {
+    process.env.NOVAHIZ_HOME = resolve(expandHome(parsed.flags.home));
+  }
+  const command = parsed.positionals[0];
+  if (command === undefined) {
+    usage();
+    return;
+  }
+  switch (command) {
+    case "check":
+      return commandCheck();
+    case "sync":
+      return commandSync();
+    case "classify":
+      return commandClassify(parsed);
+    case "gate":
+      return commandGate(parsed);
+    case "skills":
+      return commandSkills(parsed);
+    case "categories":
+      return commandCategories();
+    case "rules":
+      return commandRules();
+    case "session-load":
+      return commandSessionLoad(parsed);
+    case "session-state":
+      return commandSessionState(parsed);
+    case "report":
+      return commandReport(parsed);
+    case "clean":
+      return commandClean(parsed);
+    case "doctor":
+      return commandDoctor(parsed);
+    case "tokens":
+      return commandTokens(parsed);
+    case "catalog":
+      return commandCatalog(parsed);
+    case "roadmap":
+      return commandRoadmap(parsed);
+    case "step":
+      return commandStep(parsed);
+    case "providers":
+      return commandProviders(parsed);
+    case "deps":
+      return commandDeps(parsed);
+    case "task":
+      return commandTask(parsed);
+    case "dispatch":
+      return commandDispatch(parsed);
+    default:
+      process.stderr.write(`novahiz: unknown command ${command}\n`);
+      usage();
+      process.exitCode = 1;
+      return;
+  }
+}
+
+try {
+  main(process.argv.slice(2));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`novahiz: ${message}\n`);
+  process.exitCode = 1;
+}

package/src/commands/clean.ts

@@ -0,0 +1,114 @@
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { asString, confirm, dbPathFor, emit, flagOn, numberFlag, print, type Parsed } from "./context.ts";
+import { loadSpec, novahizHome } from "../spec.ts";
+import { openDb } from "../db.ts";
+import * as ui from "../render.ts";
+
+type CleanScope = { table: string; column: string; where?: string; label: string };
+
+const CLEAN_SCOPES: Record<string, CleanScope[]> = {
+  logs: [
+    { table: "enforcement_log", column: "logged_at", label: "journal d'enforcement" },
+    { table: "skill_invocations", column: "invoked_at", label: "invocations de skills" }
+  ],
+  roadmap: [{ table: "roadmap_progress", column: "updated_at", label: "progression de roadmap" }],
+  sessions: [{ table: "sessions", column: "updated_at", label: "sessions" }],
+  tasks: [{ table: "tasks", column: "created_at", where: "status <> 'active'", label: "taches terminees" }]
+};
+
+const CLEAN_CHOICES = ["logs", "roadmap", "sessions", "tasks", "all"];
+
+export function commandClean(parsed: Parsed): void {
+  const root = novahizHome();
+  const spec = loadSpec(root);
+  const path = dbPathFor(root, spec);
+  const daysRaw = numberFlag(parsed, "days", { min: 1, integer: true });
+  const days = daysRaw !== undefined && daysRaw > 0 ? Math.floor(daysRaw) : 30;
+  const targetRaw = (asString(parsed.flags.target) || "logs").toLowerCase();
+  if (!CLEAN_CHOICES.includes(targetRaw)) {
+    print({ error: `cible inconnue: ${targetRaw}`, choices: CLEAN_CHOICES });
+    process.exitCode = 1;
+    return;
+  }
+  const scopes = targetRaw === "all" ? Object.values(CLEAN_SCOPES).flat() : CLEAN_SCOPES[targetRaw];
+  const vacuum = flagOn(parsed, "vacuum");
+  const apply = flagOn(parsed, "apply");
+  const cutoff = new Date(Date.now() - days * 86_400_000).toISOString();
+
+  const db = openDb(path);
+  const before = statSync(path).size;
+  const plan = scopes.map((scope) => {
+    const where = `${scope.column} < ?${scope.where ? ` AND ${scope.where}` : ""}`;
+    const rows = (db.prepare(`SELECT COUNT(*) AS n FROM ${scope.table}`).get() as { n: number }).n;
+    const deletable = (db.prepare(`SELECT COUNT(*) AS n FROM ${scope.table} WHERE ${where}`).get(cutoff) as { n: number }).n;
+    return { table: scope.table, label: scope.label, rows, deletable };
+  });
+  const total = plan.reduce((sum, entry) => sum + entry.deletable, 0);
+
+  const renderPlan = (): string => {
+    const lines = [
+      ui.heading("Novahiz clean"),
+      ui.kv([
+        ["Base", `${path} (${ui.bytes(before)})`],
+        ["Cible", targetRaw],
+        ["Anciennete", `plus de ${days} jours, anterieur a ${cutoff}`],
+        ["A retirer", `${total} ligne(s)`]
+      ]),
+      "",
+      ui.table(["table", "lignes", "a supprimer"], plan.map((entry) => [entry.table, String(entry.rows), String(entry.deletable)])),
+      ""
+    ];
+    if (targetRaw === "tasks" || targetRaw === "all") {
+      lines.push(ui.style("dim", "Les todos orphelins des taches supprimees partent avec elles."));
+    }
+    return lines.join("\n");
+  };
+
+  if (!apply) {
+    const interactive = process.stdin.isTTY === true;
+    const explicitDryRun = flagOn(parsed, "dry-run");
+    if (!interactive) {
+      db.close();
+      emit(parsed, { path, days, cutoff, target: targetRaw, vacuum, applied: false, bytesBefore: before, bytesAfter: before, deleted: 0, tables: plan }, () =>
+        [renderPlan(), ui.style("dim", "Mode plan. Relance avec --apply pour supprimer.")].join("\n")
+      );
+      if (!explicitDryRun) {
+        process.stderr.write("Entree non interactive : ajoute --apply pour supprimer, ou --dry-run pour garder seulement l'apercu.\n");
+        process.exitCode = 1;
+      }
+      return;
+    }
+    process.stdout.write(`${renderPlan()}\n`);
+    if (!confirm("Supprimer ces lignes ?")) {
+      db.close();
+      process.stdout.write(`${ui.style("yellow", "Annule.")}\n`);
+      return;
+    }
+  }
+
+  let deleted = 0;
+  for (const scope of scopes) {
+    const where = `${scope.column} < ?${scope.where ? ` AND ${scope.where}` : ""}`;
+    deleted += Number(db.prepare(`DELETE FROM ${scope.table} WHERE ${where}`).run(cutoff).changes);
+  }
+  if (targetRaw === "tasks" || targetRaw === "all") {
+    deleted += Number(db.prepare("DELETE FROM todos WHERE task_id NOT IN (SELECT id FROM tasks)").run().changes);
+  }
+  if (vacuum) db.exec("VACUUM");
+  db.close();
+  const after = statSync(path).size;
+
+  const value = { path, days, cutoff, target: targetRaw, vacuum, applied: true, bytesBefore: before, bytesAfter: after, deleted, tables: plan };
+  emit(parsed, value, () =>
+    [
+      renderPlan(),
+      ui.kv([
+        ["Supprime", `${deleted} ligne(s)`],
+        ["Taille", `${ui.bytes(before)} vers ${ui.bytes(after)}`],
+        ["Vacuum", vacuum ? "oui" : "non"]
+      ])
+    ].join("\n")
+  );
+}
+