@bcelep/capint 0.4.2 → 0.6.5

package/skills/xlsx/references/examples/openpyxl/create_spreadsheet_with_styling.py

@@ -0,0 +1,96 @@
+"""Generate a styled games scoreboard workbook using openpyxl.
+
+Usage:
+  python3 create_spreadsheet_with_styling.py --output /tmp/GamesSimpleStyling.xlsx
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from openpyxl import Workbook
+from openpyxl.formatting.rule import FormulaRule
+from openpyxl.styles import Alignment, Font, PatternFill
+from openpyxl.utils import get_column_letter
+
+HEADER_FILL_HEX = "B7E1CD"
+HIGHLIGHT_FILL_HEX = "FFF2CC"
+
+
+def apply_header_style(cell, fill_hex: str) -> None:
+    cell.fill = PatternFill("solid", fgColor=fill_hex)
+    cell.font = Font(bold=True)
+    cell.alignment = Alignment(horizontal="center", vertical="center")
+
+
+def apply_highlight_style(cell, fill_hex: str) -> None:
+    cell.fill = PatternFill("solid", fgColor=fill_hex)
+    cell.font = Font(bold=True)
+    cell.alignment = Alignment(horizontal="center", vertical="center")
+
+
+def populate_game_sheet(ws) -> None:
+    ws.title = "GameX"
+    ws.row_dimensions[2].height = 24
+
+    widths = {"B": 18, "C": 14, "D": 14, "E": 14, "F": 40}
+    for col, width in widths.items():
+        ws.column_dimensions[col].width = width
+
+    headers = ["", "Name", "Game 1 Score", "Game 2 Score", "Total Score", "Notes", ""]
+    for idx, value in enumerate(headers, start=1):
+        cell = ws.cell(row=2, column=idx, value=value)
+        if value:
+            apply_header_style(cell, HEADER_FILL_HEX)
+
+    players = [
+        ("Vicky", 12, 30, "Dominated the minigames."),
+        ("Yash", 20, 10, "Emily main with strong defense."),
+        ("Bobby", 1000, 1030, "Numbers look suspiciously high."),
+    ]
+    for row_idx, (name, g1, g2, note) in enumerate(players, start=3):
+        ws.cell(row=row_idx, column=2, value=name)
+        ws.cell(row=row_idx, column=3, value=g1)
+        ws.cell(row=row_idx, column=4, value=g2)
+        ws.cell(row=row_idx, column=5, value=f"=SUM(C{row_idx}:D{row_idx})")
+        ws.cell(row=row_idx, column=6, value=note)
+
+    ws.cell(row=7, column=2, value="Winner")
+    ws.cell(row=7, column=3, value="=INDEX(B3:B5, MATCH(MAX(E3:E5), E3:E5, 0))")
+    ws.cell(row=7, column=5, value="Congrats!")
+
+    ws.merge_cells("C7:D7")
+    for col in range(2, 6):
+        apply_highlight_style(ws.cell(row=7, column=col), HIGHLIGHT_FILL_HEX)
+
+    rule = FormulaRule(formula=["LEN(A2)>0"], fill=PatternFill("solid", fgColor=HEADER_FILL_HEX))
+    ws.conditional_formatting.add("A2:G2", rule)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Create a styled games scoreboard workbook.")
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("GamesSimpleStyling.xlsx"),
+        help="Output .xlsx path (default: GamesSimpleStyling.xlsx)",
+    )
+    args = parser.parse_args()
+
+    wb = Workbook()
+    ws = wb.active
+    populate_game_sheet(ws)
+
+    for col in range(1, 8):
+        col_letter = get_column_letter(col)
+        if col_letter not in ws.column_dimensions:
+            ws.column_dimensions[col_letter].width = 12
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    wb.save(args.output)
+    print(f"Saved workbook to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/xlsx/references/examples/openpyxl/read_existing_spreadsheet.py

@@ -0,0 +1,59 @@
+"""Read an existing .xlsx and print a small summary.
+
+If --input is not provided, this script creates a tiny sample workbook in /tmp
+and reads that instead.
+"""
+
+from __future__ import annotations
+
+import argparse
+import tempfile
+from pathlib import Path
+
+from openpyxl import Workbook, load_workbook
+
+
+def create_sample(path: Path) -> Path:
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "Sample"
+    ws.append(["Item", "Qty", "Price"])
+    ws.append(["Apples", 3, 1.25])
+    ws.append(["Oranges", 2, 0.95])
+    ws.append(["Bananas", 5, 0.75])
+    ws["D1"] = "Total"
+    ws["D2"] = "=B2*C2"
+    ws["D3"] = "=B3*C3"
+    ws["D4"] = "=B4*C4"
+    wb.save(path)
+    return path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Read an existing spreadsheet.")
+    parser.add_argument("--input", type=Path, help="Path to an .xlsx file")
+    args = parser.parse_args()
+
+    if args.input:
+        input_path = args.input
+    else:
+        tmp_dir = Path(tempfile.gettempdir())
+        input_path = tmp_dir / "sample_read_existing.xlsx"
+        create_sample(input_path)
+
+    wb = load_workbook(input_path, data_only=False)
+    print(f"Loaded: {input_path}")
+    print("Sheet names:", wb.sheetnames)
+
+    for name in wb.sheetnames:
+        ws = wb[name]
+        max_row = ws.max_row or 0
+        max_col = ws.max_column or 0
+        print(f"\n== {name} (rows: {max_row}, cols: {max_col})")
+        for row in ws.iter_rows(min_row=1, max_row=min(max_row, 5), max_col=min(max_col, 5)):
+            values = [cell.value for cell in row]
+            print(values)
+
+
+if __name__ == "__main__":
+    main()

package/skills/xlsx/references/examples/openpyxl/styling_spreadsheet.py

@@ -0,0 +1,79 @@
+"""Create a styled spreadsheet with headers, borders, and a total row.
+
+Usage:
+  python3 styling_spreadsheet.py --output /tmp/styling_spreadsheet.xlsx
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from openpyxl import Workbook
+from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Create a styled spreadsheet example.")
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("styling_spreadsheet.xlsx"),
+        help="Output .xlsx path (default: styling_spreadsheet.xlsx)",
+    )
+    args = parser.parse_args()
+
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "FirstGame"
+
+    ws.merge_cells("B2:E2")
+    ws["B2"] = "Name | Game 1 Score | Game 2 Score | Total Score"
+
+    header_fill = PatternFill("solid", fgColor="B7E1CD")
+    header_font = Font(bold=True)
+    header_alignment = Alignment(horizontal="center", vertical="center")
+    ws["B2"].fill = header_fill
+    ws["B2"].font = header_font
+    ws["B2"].alignment = header_alignment
+
+    ws["B3"] = "Vicky"
+    ws["C3"] = 50
+    ws["D3"] = 60
+    ws["E3"] = "=C3+D3"
+
+    ws["B4"] = "John"
+    ws["C4"] = 40
+    ws["D4"] = 50
+    ws["E4"] = "=C4+D4"
+
+    ws["B5"] = "Jane"
+    ws["C5"] = 30
+    ws["D5"] = 40
+    ws["E5"] = "=C5+D5"
+
+    ws["B6"] = "Jim"
+    ws["C6"] = 20
+    ws["D6"] = 30
+    ws["E6"] = "=C6+D6"
+
+    ws.merge_cells("B9:E9")
+    ws["B9"] = "=SUM(E3:E6)"
+
+    thin = Side(style="thin")
+    border = Border(top=thin, bottom=thin, left=thin, right=thin)
+    ws["B9"].border = border
+    ws["B9"].alignment = Alignment(horizontal="center")
+    ws["B9"].font = Font(bold=True)
+
+    for col in ("B", "C", "D", "E"):
+        ws.column_dimensions[col].width = 18
+    ws.row_dimensions[2].height = 24
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    wb.save(args.output)
+    print(f"Saved workbook to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/xlsx/scripts/formula_engine.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Verdent XLSX Formula Engine — recalculate, audit, and diagnose Excel formulas.
+
+Modes:
+  recalc   Recalculate all formulas via LibreOffice, then audit (default)
+  audit    Scan for errors and gather formula stats without recalculating
+  deps     Show formula dependency map (which cells reference which)
+
+Usage:
+  python recalc.py <file.xlsx>                    # recalc + audit
+  python recalc.py <file.xlsx> --audit-only       # skip recalc, scan only
+  python recalc.py <file.xlsx> --deps             # formula dependency map
+  python recalc.py <file.xlsx> --timeout 60       # custom timeout
+"""
+
+import argparse, json, os, platform, re, subprocess, sys
+from collections import defaultdict
+from pathlib import Path
+
+try:
+    from openpyxl import load_workbook
+    from openpyxl.utils import get_column_letter
+except ImportError:
+    sys.exit("openpyxl is required: pip install openpyxl")
+
+KNOWN_ERRORS = {"#VALUE!", "#DIV/0!", "#REF!", "#NAME?", "#NULL!", "#NUM!", "#N/A"}
+CELL_REF_RE = re.compile(
+    r"(?:(?P<sheet>'?[A-Za-z0-9_ ]+'?)!)?"
+    r"(?P<col>\$?[A-Z]{1,3})(?P<row>\$?\d+)"
+)
+
+
+# ── LibreOffice macro bootstrap ──────────────────────────────────────
+
+_MACRO_BODY = """\
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
+<script:module xmlns:script="http://openoffice.org/2000/script"
+  script:name="Module1" script:language="StarBasic">
+  Sub RecalcAndStore()
+    Dim doc As Object
+    doc = ThisComponent
+    doc.calculateAll()
+    doc.store()
+    doc.close(True)
+  End Sub
+</script:module>"""
+
+
+def _macro_dir():
+    if platform.system() == "Darwin":
+        return Path.home() / "Library/Application Support/LibreOffice/4/user/basic/Standard"
+    return Path.home() / ".config/libreoffice/4/user/basic/Standard"
+
+
+def ensure_macro():
+    target = _macro_dir() / "Module1.xba"
+    if target.exists() and "RecalcAndStore" in target.read_text():
+        return True
+    if not target.parent.exists():
+        subprocess.run(
+            ["soffice", "--headless", "--terminate_after_init"],
+            capture_output=True, timeout=15,
+        )
+        target.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        target.write_text(_MACRO_BODY)
+        return True
+    except OSError:
+        return False
+
+
+def _find_timeout_cmd():
+    system = platform.system()
+    if system == "Linux":
+        return "timeout"
+    if system == "Darwin":
+        for candidate in ("gtimeout", "timeout"):
+            try:
+                subprocess.run([candidate, "--version"], capture_output=True, timeout=2)
+                return candidate
+            except (FileNotFoundError, subprocess.TimeoutExpired):
+                continue
+    return None
+
+
+# ── Core: recalculate ────────────────────────────────────────────────
+
+def run_recalc(filepath: Path, timeout: int = 30) -> dict:
+    if not ensure_macro():
+        return {"ok": False, "reason": "Cannot install LibreOffice macro"}
+
+    abs_str = str(filepath.resolve())
+    argv = [
+        "soffice", "--headless", "--norestore",
+        "vnd.sun.star.script:Standard.Module1.RecalcAndStore?language=Basic&location=application",
+        abs_str,
+    ]
+    wrapper = _find_timeout_cmd()
+    if wrapper:
+        argv = [wrapper, str(timeout)] + argv
+
+    proc = subprocess.run(argv, capture_output=True, text=True)
+    if proc.returncode not in (0, 124):
+        return {"ok": False, "reason": proc.stderr.strip() or "soffice exited with error"}
+    return {"ok": True}
+
+
+# ── Core: audit ──────────────────────────────────────────────────────
+
+def audit_formulas(filepath: Path) -> dict:
+    wb_vals = load_workbook(filepath, data_only=True, read_only=True)
+    wb_fmls = load_workbook(filepath, data_only=False, read_only=True)
+
+    sheet_reports = {}
+    grand_errors = 0
+    grand_formulas = 0
+
+    for sname in wb_vals.sheetnames:
+        ws_v = wb_vals[sname]
+        ws_f = wb_fmls[sname]
+
+        errors_by_type = defaultdict(list)
+        formula_cells = []
+        cell_count = 0
+
+        for row_v, row_f in zip(ws_v.iter_rows(), ws_f.iter_rows()):
+            for cv, cf in zip(row_v, row_f):
+                cell_count += 1
+                if isinstance(cf.value, str) and cf.value.startswith("="):
+                    coord = f"{sname}!{get_column_letter(cf.column)}{cf.row}"
+                    formula_cells.append(coord)
+                    grand_formulas += 1
+                if isinstance(cv.value, str):
+                    for err_tag in KNOWN_ERRORS:
+                        if err_tag in cv.value:
+                            loc = f"{sname}!{get_column_letter(cv.column)}{cv.row}"
+                            errors_by_type[err_tag].append(loc)
+                            grand_errors += 1
+                            break
+
+        sheet_reports[sname] = {
+            "cells": cell_count,
+            "formulas": len(formula_cells),
+            "errors": {k: {"count": len(v), "locations": v[:15]} for k, v in errors_by_type.items()},
+        }
+
+    wb_vals.close()
+    wb_fmls.close()
+
+    return {
+        "status": "clean" if grand_errors == 0 else "has_errors",
+        "sheets": sheet_reports,
+        "totals": {
+            "formulas": grand_formulas,
+            "errors": grand_errors,
+        },
+    }
+
+
+# ── Core: dependency map ─────────────────────────────────────────────
+
+def dependency_map(filepath: Path, limit: int = 200) -> dict:
+    wb = load_workbook(filepath, data_only=False, read_only=True)
+    deps = {}
+    count = 0
+
+    for sname in wb.sheetnames:
+        ws = wb[sname]
+        for row in ws.iter_rows():
+            for cell in row:
+                if isinstance(cell.value, str) and cell.value.startswith("="):
+                    src = f"{sname}!{get_column_letter(cell.column)}{cell.row}"
+                    refs = []
+                    for m in CELL_REF_RE.finditer(cell.value):
+                        sheet_part = m.group("sheet") or sname
+                        sheet_part = sheet_part.strip("'")
+                        refs.append(f"{sheet_part}!{m.group('col').replace('$','')}{m.group('row').replace('$','')}")
+                    if refs:
+                        deps[src] = {"formula": cell.value, "references": refs}
+                        count += 1
+                        if count >= limit:
+                            wb.close()
+                            return {"dependencies": deps, "truncated": True, "shown": count}
+
+    wb.close()
+    return {"dependencies": deps, "truncated": False, "shown": count}
+
+
+# ── CLI ──────────────────────────────────────────────────────────────
+
+def main():
+    ap = argparse.ArgumentParser(description="Verdent XLSX Formula Engine")
+    ap.add_argument("file", help="Excel file path")
+    ap.add_argument("--audit-only", action="store_true", help="Scan without recalculating")
+    ap.add_argument("--deps", action="store_true", help="Show formula dependency map")
+    ap.add_argument("--timeout", type=int, default=30, help="LibreOffice timeout in seconds")
+    args = ap.parse_args()
+
+    fp = Path(args.file)
+    if not fp.exists():
+        sys.exit(json.dumps({"error": f"{args.file} not found"}))
+
+    if args.deps:
+        print(json.dumps(dependency_map(fp), indent=2))
+        return
+
+    if not args.audit_only:
+        rc = run_recalc(fp, args.timeout)
+        if not rc["ok"]:
+            sys.exit(json.dumps({"error": rc["reason"]}))
+
+    report = audit_formulas(fp)
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/skills/xlsx/scripts/profile.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Quick data profiling for spreadsheet files. Outputs a JSON summary."""
+
+import json, sys
+from pathlib import Path
+
+import pandas as pd
+
+
+def profile(filepath, sheet=None, max_rows=None):
+    ext = Path(filepath).suffix.lower()
+    kw = {}
+    if max_rows:
+        kw["nrows"] = max_rows
+
+    if ext in (".csv", ".tsv"):
+        sep = "\t" if ext == ".tsv" else ","
+        df = pd.read_csv(filepath, sep=sep, **kw)
+        sheets = {"data": df}
+    else:
+        target = sheet if sheet else None
+        raw = pd.read_excel(filepath, sheet_name=target or None, **kw)
+        sheets = raw if isinstance(raw, dict) else {target or "Sheet1": raw}
+
+    result = {}
+    for name, df in sheets.items():
+        cols = []
+        for c in df.columns:
+            info = {
+                "name": str(c),
+                "dtype": str(df[c].dtype),
+                "non_null": int(df[c].count()),
+                "null": int(df[c].isnull().sum()),
+                "unique": int(df[c].nunique()),
+            }
+            if pd.api.types.is_numeric_dtype(df[c]):
+                desc = df[c].describe()
+                info["min"] = float(desc.get("min", 0))
+                info["max"] = float(desc.get("max", 0))
+                info["mean"] = round(float(desc.get("mean", 0)), 4)
+                info["std"] = round(float(desc.get("std", 0)), 4)
+            elif pd.api.types.is_string_dtype(df[c]):
+                top = df[c].value_counts().head(5)
+                info["top_values"] = {str(k): int(v) for k, v in top.items()}
+            cols.append(info)
+        result[name] = {"rows": len(df), "columns": len(df.columns), "column_profiles": cols}
+
+    return result
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python profile.py <file> [sheet_name] [max_rows]")
+        sys.exit(1)
+    fp = sys.argv[1]
+    sh = sys.argv[2] if len(sys.argv) > 2 and not sys.argv[2].isdigit() else None
+    mr = None
+    for a in sys.argv[2:]:
+        if a.isdigit():
+            mr = int(a)
+            break
+    print(json.dumps(profile(fp, sh, mr), indent=2, default=str))

package/src/commands/init.js

@@ -1,15 +1,29 @@
 const path = require("path");
+const fs = require("fs");
 const { runScaffold, PRESET_MANIFEST } = require("../lib/scaffold");
 const { syncIdeProjections, appendIdeManifestEntries } = require("../lib/ide-sync");
+const {
+  listPackageSkillNames,
+  listProjectSkillNames,
+  pkgRoot,
+  normalizeBundleMode,
+  MINIMAL_BUNDLE_SKILLS
+} = require("../lib/scaffold/presets");
 
 module.exports = async function init(args, flags) {
   const rootDir = process.cwd();
   const preset = flags.preset || "minimal";
+  const bundle = flags.bundle || "full";
   const projectName = flags.name || path.basename(rootDir);
   const force = Boolean(flags.force);
   const ideSync = !flags["no-ide-sync"];
 
-  const report = runScaffold({ rootDir, preset, projectName, force });
+  if (!normalizeBundleMode(bundle)) {
+    console.error(`Unknown --bundle "${bundle}". Use full or minimal.`);
+    process.exit(1);
+  }
+
+  const report = runScaffold({ rootDir, preset, projectName, force, bundle });
   if (report.error) {
     console.error(report.error);
     process.exit(1);
@@ -30,8 +44,17 @@ module.exports = async function init(args, flags) {
 
   console.log("\n## CapInt Init\n");
   console.log(`Preset: ${preset}`);
+  console.log(`Bundle: ${report.bundle || bundle}`);
   console.log(`Project: ${projectName}`);
-  console.log(`Created: ${report.summary.created}, Updated: ${report.summary.updated}, Skipped: ${report.summary.skipped}, Conflicts: ${report.summary.conflict}\n`);
+  console.log(`Created: ${report.summary.created}, Updated: ${report.summary.updated}, Skipped: ${report.summary.skipped}, Conflicts: ${report.summary.conflict}`);
+  const projectSkills = listProjectSkillNames(rootDir).length;
+  const workflowCount = fs.existsSync(path.join(rootDir, "workflows"))
+    ? fs.readdirSync(path.join(rootDir, "workflows")).filter((f) => f.endsWith(".md")).length
+    : 0;
+  const pkgSkills = listPackageSkillNames(pkgRoot()).length;
+  console.log(
+    `Skills: ${projectSkills} on disk${report.bundle === "minimal" ? ` (minimal stub; package has ${pkgSkills})` : ""}, ${workflowCount} workflows\n`
+  );
   for (const r of report.results) {
     const extra = r.sidecar ? ` -> see ${r.sidecar}` : r.reason ? ` (${r.reason})` : "";
     console.log(`  [${r.action}] ${r.path}${extra}`);
@@ -45,6 +68,7 @@ module.exports = async function init(args, flags) {
   } else if (!ideSync) {
     console.log("\nIDE sync skipped (--no-ide-sync). Run: capint ide sync");
   }
-  console.log("\nNext: capint route \"i18n\"");
+  console.log("\nNext: open GUNLUK.md — then chat your first task (no terminal needed)");
+  console.log("       capint route \"i18n\"  (optional preview)");
   console.log("Conflict policy: existing files without capint managed blocks are never overwritten.\n");
 };

package/src/commands/pipeline.js

@@ -0,0 +1,31 @@
+module.exports = async function pipeline(args, flags) {
+  const rootDir = process.cwd();
+  const { runPipeline } = require("../lib/pipeline");
+  const fs = require("fs");
+
+  if (!fs.existsSync(require("path").join(rootDir, "skill-routing-matrix.json"))) {
+    console.error("Not a CapInt project — run capint init first.");
+    process.exit(1);
+  }
+
+  const task = args.filter((a) => !a.startsWith("--")).join(" ").trim() || null;
+  const result = runPipeline(rootDir, { task, skipIde: Boolean(flags["skip-ide"]) });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.pass && !flags.force) process.exit(1);
+    return;
+  }
+
+  console.log("\n## CapInt Pipeline\n");
+  result.steps.forEach((step, i) => {
+    const mark = step.ok ? "✓" : step.advisory ? "!" : "✗";
+    console.log(`[${i + 1}/${result.steps.length}] ${step.id}: ${mark} ${step.summary}`);
+  });
+  console.log(`\nOverall: ${result.pass ? "PASS" : "FAIL"}`);
+  if (!result.pass) {
+    console.log("Hint: capint doctor · capint recover --list · capint ide sync");
+    if (!flags.force) process.exit(1);
+  }
+  console.log("");
+};

package/src/commands/recover.js

@@ -0,0 +1,62 @@
+module.exports = async function recover(args, flags) {
+  const rootDir = process.cwd();
+  const { listBackups, planRecover, applyRecover } = require("../lib/recover");
+
+  const apply = Boolean(flags.apply);
+  const latest = Boolean(flags.latest);
+
+  if (flags.list || (!apply && !latest && !flags.stamp)) {
+    const { groups, backups } = listBackups(rootDir);
+    if (flags.json) {
+      console.log(JSON.stringify({ groups, backups }, null, 2));
+      return;
+    }
+    console.log("\n## CapInt backups\n");
+    if (!groups.length) {
+      console.log("No backups found. Run: capint upgrade --apply");
+      console.log("");
+      return;
+    }
+    for (const g of groups) {
+      const when = new Date(g.mtime).toISOString();
+      console.log(`  ${g.stamp}  (${when})`);
+      for (const f of g.files) console.log(`    → ${f.target}  ←  ${f.file}`);
+    }
+    console.log("\nRestore latest (dry-run): capint recover --latest");
+    console.log("Restore latest (apply):    capint recover --latest --apply\n");
+    return;
+  }
+
+  const plan = planRecover(rootDir, { stamp: flags.stamp, latest: latest || Boolean(flags.stamp) });
+  if (plan.error) {
+    console.error(plan.error);
+    if (plan.groups?.length && !flags.json) {
+      console.error("Available stamps:");
+      for (const g of plan.groups.slice(0, 5)) console.error(`  ${g.stamp}`);
+    }
+    process.exit(1);
+  }
+
+  if (!apply) {
+    if (flags.json) {
+      console.log(JSON.stringify({ dry_run: true, ...plan }, null, 2));
+      return;
+    }
+    console.log("\n## Recover (dry-run)\n");
+    console.log(`Stamp: ${plan.stamp}`);
+    for (const a of plan.actions) {
+      console.log(`  would restore ${a.target}`);
+    }
+    console.log("\nApply: capint recover --latest --apply\n");
+    return;
+  }
+
+  const result = applyRecover(rootDir, plan);
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log("\n## Recover applied\n");
+  console.log(`Stamp: ${result.stamp}`);
+  console.log(`Restored: ${result.restored.join(", ") || "(none)"}\n`);
+};

package/src/commands/route.js

@@ -21,6 +21,13 @@ module.exports = async function route(args, flags) {
   }
 
   const result = routeTask(text, rootDir);
+  const { logDebug } = require("../lib/env-flags");
+  logDebug(rootDir, {
+    step: "route",
+    capability: result.execution_intent?.capability,
+    task_type: result.execution_intent?.explanation?.task_type_id,
+    winner: result.execution_intent?.explanation?.winner
+  });
   if (flags.json) {
     console.log(JSON.stringify(result, null, 2));
     return;