@minhpnq1807/contextos 0.5.7 → 0.5.9

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.5.9
+
+- Formats `ctx report`, `ctx evidence`, `ctx stats`, and `ctx benchmark` with sectioned terminal tables for easier scanning and analysis.
+- Adds a small shared terminal table formatter used by report, evidence, stats, and benchmark output.
+
+## 0.5.8
+
+- Adds explicit `ctx setup` interactive onboarding for installing agents, enabling injection, syncing Ruler rules/MCP servers, and syncing skills through skillshare.
+- Adds non-interactive setup flags: `--yes`, `--agents`, `--no-rules`, `--no-skills`, `--quiet`, and `--no-inject`.
+- Keeps npm install lifecycle clean; setup only runs when the user explicitly invokes `ctx setup`.
+
 ## 0.5.7
 
 - Adds thin passthrough commands `ctx ruler -- <args>` and `ctx skillshare -- <args>` for upstream admin/debug workflows without reimplementing those CLIs.

package/README.md

@@ -11,10 +11,25 @@ Published package: [`@minhpnq1807/contextos`](https://www.npmjs.com/package/@min
 ```bash
 npm install -g @minhpnq1807/contextos
 ctx --version
-ctx install
+ctx setup
+```
+
+`ctx setup` is the recommended first-run flow. It asks which agents to configure, whether prompt context injection should be enabled, whether to sync project rules/MCP through Ruler, and whether to sync skills through skillshare. It only runs when you explicitly invoke it; npm install does not run setup automatically.
+
+For scriptable installs, use:
+
+```bash
+ctx setup --yes
+ctx setup --yes --agents codex,claude,agy
 ```
 
-Restart Codex after installing, then use Codex normally. ContextOS runs through Codex hooks and the `ctx-mcp` MCP server.
+Restart your agent after setup, then use it normally. ContextOS runs through agent hooks and the `ctx-mcp` MCP server.
+
+Codex-only install is still available:
+
+```bash
+ctx install
+```
 
 Claude Code and Antigravity are supported through their native hook systems:
 
@@ -27,6 +42,7 @@ You can also run without a global install:
 
 ```bash
 npx @minhpnq1807/contextos@latest install
+npx @minhpnq1807/contextos@latest setup
 npx @minhpnq1807/contextos@latest install claude
 npx @minhpnq1807/contextos@latest install agy
 ```
@@ -323,11 +339,17 @@ This warning comes from a transitive dependency in the local embedding/WASM stac
 | `ctx install --quiet` | Installs ContextOS in measurement-only mode. | You want reports and stats but do not want visible injected context. | Installs the same hooks, but prompt hooks return empty context. |
 | `ctx install --inject` | Installs ContextOS with explicit injection mode. | You want to be explicit in scripts or docs. | Same runtime behavior as the default install mode; if combined with `--quiet`, `--inject` wins. |
 | `ctx install --copy` | Copies only the plugin payload to `$CODEX_HOME/plugins/ctx`. | Local development or manual plugin experiments. | Does not register marketplace, MCP, or global hooks. |
+| `ctx setup` | Runs the first-run setup wizard. | You want the recommended onboarding flow after `npm install -g @minhpnq1807/contextos`. | Installs selected agents, optionally syncs Ruler rules/MCP and skillshare skills, then prints next steps. |
+| `ctx setup --yes` | Runs setup with defaults non-interactively. | You want scriptable all-agent setup. | Uses `codex,claude,agy`, enables injection, syncs rules, syncs skills, and passes `--yes` to dependency setup prompts. |
+| `ctx setup --agents <list>` | Runs setup for selected agents. | You want only part of the default set. | Accepts comma-separated `codex`, `claude`, `agy`, or `antigravity`. |
+| `ctx setup --no-rules` | Skips Ruler sync during setup. | You only want hooks/MCP install and maybe skill sync. | Does not run `ctx sync --rules`. |
+| `ctx setup --no-skills` | Skips skillshare sync during setup. | You do not want shared skills configured. | Does not run `ctx sync --skills`. |
+| `ctx setup --quiet` | Runs setup in measurement-only mode. | You want reports/stats without visible injected prompt context. | Installs hooks with prompt context injection disabled. |
 | `ctx debug -- "task"` | Runs the scheduler locally for a fake prompt. | You want to see which AGENTS.md rules and files ContextOS would inject before using Codex. | Prints rule scores, scoring reasons, suggested files, and final `additionalContext`. |
-| `ctx report` | Shows the last Stop-hook compliance report for the current workspace. | An agent task has finished and you want the summary again. | Reads `~/.ctx/contextos/workspaces/<workspace-id>/last-report.json`. |
-| `ctx evidence` | Shows detailed evidence behind the last report for the current workspace. | You want to inspect why a rule was marked `followed`, `ignored`, or `unknown`. | Prints rule text, source file, score, status, and evidence reason. |
-| `ctx stats` | Shows aggregate runtime metrics for the current workspace. | You want to know whether ContextOS is active and useful over time. | Prints prompt count, report count, injected/quiet ratio, average prompt analysis time, efficiency, rule outcomes, hook events, and last suggested files for the current workspace only. |
-| `ctx benchmark -- "task"` | Compares baseline AGENTS.md ordering with ContextOS task-aware scheduling. | You want a before/after signal for lost-in-the-middle risk. | Prints parsed/actionable/filtered rule counts, relevant rules in the middle of the original file, scheduled high/mid rules, and top scored rules. |
+| `ctx report` | Shows the last Stop-hook compliance report for the current workspace. | An agent task has finished and you want the summary again. | Prints sectioned tables for summary, rule outcomes, suggested files, and runtime telemetry from `~/.ctx/contextos/workspaces/<workspace-id>/last-report.json`. |
+| `ctx evidence` | Shows detailed evidence behind the last report for the current workspace. | You want to inspect why a rule was marked `followed`, `ignored`, `unknown`, or `unmeasurable`. | Prints a compact evidence table plus per-rule detail tables. |
+| `ctx stats` | Shows aggregate runtime metrics for the current workspace. | You want to know whether ContextOS is active and useful over time. | Prints sectioned tables for prompt/report counts, injection rate, efficiency, rule outcomes, hook events, last prompt, and last report. |
+| `ctx benchmark -- "task"` | Compares baseline AGENTS.md ordering with ContextOS task-aware scheduling. | You want a before/after signal for lost-in-the-middle risk. | Prints tables for parsed/actionable/filtered rules, baseline middle-risk, scheduled high/mid rules, recency reminder status, and top scored rules. |
 | `ctx sync --rules` | Syncs project rules and MCP servers through Ruler. | You want Codex, Claude Code, and Antigravity to share one project rule/MCP source of truth. | Ensures `.ruler/ruler.toml`, injects `ctx-mcp`, imports existing MCP servers from Codex and project `.mcp.json`, runs `ruler apply --agents codex,claude,antigravity`, mirrors MCP servers to Antigravity MCP configs, and verifies generated config. |
 | `ctx sync --rules --agents <list>` | Syncs only selected agents through Ruler. | You want to update one or two agents without touching the others. | Accepts comma-separated values such as `codex`, `claude`, `agy`, `antigravity`, or `codex,claude,agy`; `agy` is normalized to Ruler's `antigravity`. |
 | `ctx sync --rules --dry-run` | Previews Ruler sync without writing files or running apply. | You want to inspect behavior before changing project config. | Prints the same flow with dry-run status. |

package/bin/ctx.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { execFileSync } from "node:child_process";
 
@@ -25,6 +27,7 @@ import { syncRules } from "../plugins/ctx/lib/ruler-sync.js";
 import { syncSkills } from "../plugins/ctx/lib/skillshare-sync.js";
 import { scanSkills, warmSkillEmbeddings } from "../plugins/ctx/lib/skill-discoverer.js";
 import { parsePassthroughArgs, runPassthrough } from "../plugins/ctx/lib/passthrough.js";
+import { parseAgentList, parseSetupArgs, setupSummaryLines } from "../plugins/ctx/lib/setup-wizard.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(__dirname, "..");
@@ -42,6 +45,12 @@ Usage:
   ctx install --quiet
   ctx install --inject
   ctx install --copy
+  ctx setup
+  ctx setup --yes
+  ctx setup --agents codex,claude,agy
+  ctx setup --no-rules
+  ctx setup --no-skills
+  ctx setup --quiet
   ctx debug -- "task"
   ctx report
   ctx evidence
@@ -394,6 +403,96 @@ async function warmEmbeddings(task) {
   console.log(`Cache: ${result.cachePath}`);
 }
 
+function printSetupBanner() {
+  console.log("");
+  console.log("╭─ ContextOS setup ─────────────────────────────────────────╮");
+  console.log("│ Task-aware rules, MCP sync, and skill discovery for agents │");
+  console.log("╰───────────────────────────────────────────────────────────╯");
+  console.log("");
+}
+
+async function askSetupQuestion(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  const answer = await rl.question(`◇ ${question}${suffix}: `);
+  return answer.trim() || defaultValue;
+}
+
+async function askSetupYesNo(rl, question, defaultValue = true) {
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const answer = await askSetupQuestion(rl, question, suffix);
+  if (!answer || answer === suffix) return defaultValue;
+  return !/^n(o)?$/i.test(answer.trim());
+}
+
+async function setup({ args = [], cwd = process.cwd() } = {}) {
+  const options = parseSetupArgs(args);
+  const interactive = !options.yes && process.stdin.isTTY;
+
+  printSetupBanner();
+  console.log(`◇ Installation directory:\n│  ${cwd}`);
+
+  if (interactive) {
+    const rl = readline.createInterface({ input, output });
+    try {
+      const proceed = await askSetupYesNo(rl, "Install to this directory?", true);
+      if (!proceed) {
+        console.log("Setup cancelled.");
+        return;
+      }
+      const agents = await askSetupQuestion(rl, "Install for agents? comma-separated", options.agents.join(","));
+      options.agents = parseAgentList(agents);
+      options.inject = await askSetupYesNo(rl, "Enable prompt context injection?", options.inject);
+      options.syncRules = await askSetupYesNo(rl, "Sync project rules and MCP servers through Ruler?", options.syncRules);
+      options.syncSkills = await askSetupYesNo(rl, "Sync skills through skillshare?", options.syncSkills);
+    } finally {
+      rl.close();
+    }
+  }
+
+  console.log("");
+  console.log("◇ Ready to setup:");
+  for (const line of setupSummaryLines({ cwd, ...options })) console.log(`│  ${line}`);
+  console.log("");
+
+  if (!options.agents.length) throw new Error("No agents selected. Use --agents codex,claude,agy.");
+
+  for (const agent of options.agents) {
+    console.log(`● Setting up ${agent}...`);
+    await install({ agent, inject: options.inject, copy: false });
+  }
+
+  if (options.syncRules) {
+    console.log("● Syncing project rules and MCP servers...");
+    const syncAgents = options.agents.map((agent) => agent === "agy" ? "antigravity" : agent).join(",");
+    const syncArgs = ["--rules", "--agents", syncAgents];
+    if (options.yes) syncArgs.push("--yes");
+    await syncRules({ cwd, rootDir, args: syncArgs });
+  }
+
+  if (options.syncSkills) {
+    console.log("● Syncing skills...");
+    const skillAgents = options.agents.map((agent) => agent === "agy" ? "antigravity" : agent).join(",");
+    const syncArgs = ["--skills", "--agents", skillAgents];
+    if (options.yes) syncArgs.push("--yes");
+    await syncSkills({
+      cwd,
+      args: syncArgs,
+      rebuildSkillEmbeddings: async ({ cwd: skillCwd, sourceDir }) => warmSkillEmbeddings({
+        cwd: skillCwd,
+        dataDir: contextOSDataDir(),
+        allowRemote: !isModelCacheReady(contextOSDataDir()),
+        skills: scanSkills({ cwd: skillCwd, roots: [sourceDir] })
+      })
+    });
+  }
+
+  console.log("");
+  console.log("╭─ ContextOS is ready ───────────────────────────────────────╮");
+  console.log("│ Next: restart/open your agent from this project directory. │");
+  console.log("│ Try: ctx debug -- \"Recheck authen flow\"                  │");
+  console.log("╰───────────────────────────────────────────────────────────╯");
+}
+
 const args = process.argv.slice(2);
 const command = args[0];
 
@@ -415,6 +514,8 @@ try {
       inject: args.includes("--inject") || !args.includes("--quiet"),
       agent: installAgentFromArgs(args)
     });
+  } else if (command === "setup") {
+    await setup({ args: args.slice(1), cwd: process.cwd() });
   } else if (command === "debug") {
     const marker = args.indexOf("--");
     const task = marker >= 0 ? args.slice(marker + 1).join(" ") : args.slice(1).join(" ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhpnq1807/contextos",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Task-aware AGENTS.md context injection and compliance reporting for Codex, Claude Code, and Antigravity.",
   "type": "module",
   "bin": {

package/plugins/ctx/lib/benchmark.js

@@ -1,6 +1,7 @@
 import { parseRules, filterActionableRules, scoreRules } from "./analyzer.js";
 import { readAgentsChain } from "./reader.js";
 import { scheduleContext } from "./scheduler.js";
+import { section, table, truncateCell } from "./terminal-ui.js";
 
 export function benchmarkContext({ markdown, sources = [], task = "", openFiles = [], topK = 8 } = {}) {
   const parsedRules = parseRules(markdown);
@@ -55,18 +56,24 @@ export function benchmarkWorkspace({ cwd = process.cwd(), task = "", openFiles =
 export function formatBenchmark(result) {
   const lines = [];
   lines.push("ContextOS benchmark");
-  lines.push(`Task: ${result.task || "(empty)"}`);
-  lines.push(`Rules: ${result.rulesParsed} parsed, ${result.actionableRules} actionable, ${result.filteredRules} filtered`);
-  lines.push(`Relevant rules: ${result.relevantRules}`);
-  lines.push(`Baseline middle-risk: ${result.baseline.relevantRulesInMiddle}/${result.relevantRules} relevant rules (${result.baseline.middleRiskPercent}%)`);
-  lines.push(`ContextOS scheduled: ${result.contextOS.highRules} high, ${result.contextOS.midRules} mid`);
-  lines.push(`Recency reminder: ${result.contextOS.repeatsHighRulesAtEnd ? "enabled" : "not needed"}`);
+  lines.push(section("Summary"));
+  lines.push(table(["Metric", "Value"], [
+    ["Task", truncateCell(result.task || "(empty)", 100)],
+    ["Rules parsed", result.rulesParsed],
+    ["Actionable rules", result.actionableRules],
+    ["Filtered rules", result.filteredRules],
+    ["Relevant rules", result.relevantRules],
+    ["Baseline middle-risk", `${result.baseline.relevantRulesInMiddle}/${result.relevantRules} relevant rules (${result.baseline.middleRiskPercent}%)`],
+    ["ContextOS scheduled", `${result.contextOS.highRules} high, ${result.contextOS.midRules} mid`],
+    ["Recency reminder", result.contextOS.repeatsHighRulesAtEnd ? "enabled" : "not needed"]
+  ]));
   if (result.contextOS.topRules.length) {
-    lines.push("Top rules:");
-    for (const rule of result.contextOS.topRules) {
-      const reasons = rule.reasons?.length ? ` reasons:${rule.reasons.join(",")}` : "";
-      lines.push(`- ${Number(rule.score || 0).toFixed(2)} ${rule.content}${reasons}`);
-    }
+    lines.push(section("Top Rules"));
+    lines.push(table(["Score", "Rule", "Reasons"], result.contextOS.topRules.map((rule) => [
+      Number(rule.score || 0).toFixed(2),
+      truncateCell(rule.content, 88),
+      truncateCell(rule.reasons?.join(", ") || "", 40)
+    ])));
   }
   return lines.join("\n");
 }

package/plugins/ctx/lib/reporter.js

@@ -1,4 +1,5 @@
 import { isSystemUserRule } from "./analyzer.js";
+import { section, table, truncateCell } from "./terminal-ui.js";
 
 export function buildReport({ cwd, prompt, relevantFiles, scheduled, gitSnapshot, compliance, runtimeEvidence }) {
   const actionableCompliance = compliance.filter((item) => !isSystemUserRule(item.rule));
@@ -33,17 +34,33 @@ export function formatReport(report) {
   report = sanitizeReport(report);
   const lines = [];
   lines.push("ContextOS report");
-  lines.push(`Efficiency: ${report.efficiencyScore == null ? "unknown" : `${report.efficiencyScore}%`}`);
-  lines.push(`Injected rules: ${report.injectedRuleCount || 0}`);
-  lines.push(`Rule outcomes: ${report.followed?.length || 0} followed, ${report.ignored?.length || 0} ignored, ${report.unknown?.length || 0} unknown, ${report.unmeasurable?.length || 0} unmeasurable`);
-  lines.push(`Measured rules: ${report.measuredRuleCount ?? ((report.followed?.length || 0) + (report.ignored?.length || 0))}`);
-  lines.push(`Changed files: ${report.changedFiles?.length ? report.changedFiles.join(", ") : "none detected"}`);
+  lines.push(section("Summary"));
+  lines.push(table(["Metric", "Value"], [
+    ["Efficiency", report.efficiencyScore == null ? "unknown" : `${report.efficiencyScore}%`],
+    ["Injected rules", report.injectedRuleCount || 0],
+    ["Measured rules", report.measuredRuleCount ?? ((report.followed?.length || 0) + (report.ignored?.length || 0))],
+    ["Changed files", report.changedFiles?.length ? report.changedFiles.length : "none detected"]
+  ]));
+
+  lines.push(section("Rule Outcomes"));
+  lines.push(table(["Status", "Count"], [
+    ["followed", report.followed?.length || 0],
+    ["ignored", report.ignored?.length || 0],
+    ["unknown", report.unknown?.length || 0],
+    ["unmeasurable", report.unmeasurable?.length || 0]
+  ]));
 
   if (report.relevantFiles?.length) {
-    lines.push(`Suggested files: ${report.relevantFiles.map((file) => file.path).join(", ")}`);
+    lines.push(section("Suggested Files"));
+    lines.push(table(["#", "Path", "Score"], report.relevantFiles.slice(0, 10).map((file, index) => [
+      index + 1,
+      truncateCell(file.path, 90),
+      typeof file.score === "number" ? file.score.toFixed(2) : ""
+    ])));
   }
   if (report.runtimeEvidence?.signals?.length) {
-    lines.push(`Runtime telemetry: ${report.runtimeEvidence.signals.join(", ")}`);
+    lines.push(section("Runtime Telemetry"));
+    lines.push(table(["#", "Signal"], report.runtimeEvidence.signals.map((signal, index) => [index + 1, signal])));
   }
 
   for (const warning of report.warnings || []) lines.push(`Warning: ${warning}`);
@@ -66,9 +83,12 @@ export function formatEvidence(report) {
   report = sanitizeReport(report);
   const lines = [];
   lines.push("ContextOS evidence");
-  lines.push(`Prompt: ${report.prompt || "(empty)"}`);
-  lines.push(`Efficiency: ${report.efficiencyScore == null ? "unknown" : `${report.efficiencyScore}%`}`);
-  lines.push(`Changed files: ${report.changedFiles?.length ? report.changedFiles.join(", ") : "none detected"}`);
+  lines.push(section("Summary"));
+  lines.push(table(["Field", "Value"], [
+    ["Prompt", truncateCell(report.prompt || "(empty)", 100)],
+    ["Efficiency", report.efficiencyScore == null ? "unknown" : `${report.efficiencyScore}%`],
+    ["Changed files", report.changedFiles?.length ? report.changedFiles.join(", ") : "none detected"]
+  ]));
 
   for (const warning of report.warnings || []) lines.push(`Warning: ${warning}`);
 
@@ -85,15 +105,26 @@ export function formatEvidence(report) {
     return lines.join("\n");
   }
 
+  lines.push(section("Evidence Table"));
+  lines.push(table(["#", "Status", "Score", "Kind", "Rule", "Evidence"], items.map((item, index) => [
+    index + 1,
+    item.status.toUpperCase(),
+    typeof item.rule?.score === "number" ? item.rule.score.toFixed(2) : "",
+    item.kind || "",
+    truncateCell(item.rule?.content || "(missing rule)", 46),
+    truncateCell(item.evidence || "(none)", 58)
+  ])));
+
   items.forEach((item, index) => {
-    lines.push("");
-    lines.push(`${index + 1}. ${item.status.toUpperCase()}`);
-    lines.push(`Rule: ${item.rule?.content || "(missing rule)"}`);
-    if (item.rule?.sourcePath) lines.push(`Source: ${item.rule.sourcePath}`);
-    if (typeof item.rule?.score === "number") lines.push(`Score: ${item.rule.score.toFixed(2)}`);
-    if (item.kind) lines.push(`Kind: ${item.kind}`);
-    if (item.keywords?.length) lines.push(`Keywords: ${item.keywords.join(", ")}`);
-    lines.push(`Evidence: ${item.evidence || "(none)"}`);
+    lines.push(section(`${index + 1}. ${item.status.toUpperCase()}`));
+    lines.push(table(["Field", "Value"], [
+      ["Rule", truncateCell(item.rule?.content || "(missing rule)", 120)],
+      ["Source", item.rule?.sourcePath || ""],
+      ["Score", typeof item.rule?.score === "number" ? item.rule.score.toFixed(2) : ""],
+      ["Kind", item.kind || ""],
+      ["Keywords", item.keywords?.length ? truncateCell(item.keywords.join(", "), 120) : ""],
+      ["Evidence", truncateCell(item.evidence || "(none)", 120)]
+    ].filter(([, value]) => value !== "")));
     for (const line of item.matchedLines || []) {
       const where = line.file ? `${line.file}${typeof line.line === "number" ? `:${line.line}` : ""}` : "diff";
       lines.push(`Matched line: ${where} ${truncate(line.content || "", 140)}`);

package/plugins/ctx/lib/setup-wizard.js

@@ -0,0 +1,47 @@
+const DEFAULT_AGENTS = ["codex", "claude", "agy"];
+
+export function parseSetupArgs(args = []) {
+  const agentsFlag = args.indexOf("--agents");
+  const agents = agentsFlag >= 0
+    ? parseAgentList(args[agentsFlag + 1])
+    : DEFAULT_AGENTS;
+
+  return {
+    agents,
+    yes: args.includes("--yes") || args.includes("-y"),
+    quiet: args.includes("--quiet"),
+    inject: !args.includes("--quiet") && !args.includes("--no-inject"),
+    syncRules: !args.includes("--no-rules"),
+    syncSkills: !args.includes("--no-skills")
+  };
+}
+
+export function parseAgentList(value = "") {
+  const agents = String(value || "")
+    .split(",")
+    .map((item) => normalizeSetupAgent(item))
+    .filter(Boolean);
+  return [...new Set(agents)];
+}
+
+export function normalizeSetupAgent(agent) {
+  const normalized = String(agent || "").trim().toLowerCase();
+  if (normalized === "antigravity") return "agy";
+  return normalized;
+}
+
+export function setupSummaryLines({
+  cwd = process.cwd(),
+  agents = DEFAULT_AGENTS,
+  inject = true,
+  syncRules = true,
+  syncSkills = true
+} = {}) {
+  return [
+    `Installation directory: ${cwd}`,
+    `Agents: ${agents.join(", ") || "(none)"}`,
+    `Prompt context injection: ${inject ? "enabled" : "quiet logging only"}`,
+    `Ruler rule/MCP sync: ${syncRules ? "enabled" : "skipped"}`,
+    `skillshare skill sync: ${syncSkills ? "enabled" : "skipped"}`
+  ];
+}

package/plugins/ctx/lib/stats.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { safeReadText } from "./fs-utils.js";
+import { section, table, truncateCell } from "./terminal-ui.js";
 
 function readJsonLines(filePath) {
   return safeReadText(filePath)
@@ -81,33 +82,47 @@ export function loadStats(dataDir) {
 export function formatStats(stats) {
   const lines = [];
   lines.push("ContextOS stats");
-  lines.push(`Data dir: ${stats.dataDir}`);
-  lines.push(`Prompts analyzed: ${stats.promptCount}`);
-  lines.push(`Reports generated: ${stats.reportCount}`);
-  lines.push(`Prompt mode: ${stats.injectedCount} injected, ${stats.quietCount} quiet (${stats.injectionRate}% injected)`);
-  lines.push(`Average prompt analysis: ${stats.averagePromptMs == null ? "unknown" : `${stats.averagePromptMs}ms`}`);
-  lines.push(`Average efficiency: ${formatAverageEfficiency(stats)}`);
-  lines.push(`Rule outcomes: ${stats.followed} followed, ${stats.ignored} ignored, ${stats.unknown} unknown, ${stats.unmeasurable || 0} unmeasurable`);
-
-  const eventSummary = Object.entries(stats.events)
-    .map(([event, count]) => `${event}:${count}`)
-    .join(", ");
-  lines.push(`Hook events: ${eventSummary || "none"}`);
+  lines.push(section("Summary"));
+  lines.push(table(["Metric", "Value"], [
+    ["Data dir", stats.dataDir],
+    ["Prompts analyzed", stats.promptCount],
+    ["Reports generated", stats.reportCount],
+    ["Prompt mode", `${stats.injectedCount} injected, ${stats.quietCount} quiet (${stats.injectionRate}% injected)`],
+    ["Average prompt analysis", stats.averagePromptMs == null ? "unknown" : `${stats.averagePromptMs}ms`],
+    ["Average efficiency", formatAverageEfficiency(stats)]
+  ]));
+
+  lines.push(section("Rule Outcomes"));
+  lines.push(table(["Status", "Count"], [
+    ["followed", stats.followed],
+    ["ignored", stats.ignored],
+    ["unknown", stats.unknown],
+    ["unmeasurable", stats.unmeasurable || 0]
+  ]));
+
+  lines.push(section("Hook Events"));
+  lines.push(Object.keys(stats.events).length
+    ? table(["Event", "Count"], Object.entries(stats.events))
+    : "none");
 
   if (stats.lastPrompt) {
-    lines.push(`Last prompt: ${truncateLine(stats.lastPrompt.prompt || "", 100) || "(empty)"}`);
-    lines.push(`Last scheduled rules: ${scheduledRuleCount(stats.lastPrompt)}`);
-    const files = (stats.lastPrompt.relevantFiles || []).map((file) => file.path).join(", ");
-    if (files) lines.push(`Last suggested files: ${files}`);
+    lines.push(section("Last Prompt"));
+    lines.push(table(["Field", "Value"], [
+      ["Prompt", truncateCell(stats.lastPrompt.prompt || "(empty)", 100)],
+      ["Scheduled rules", scheduledRuleCount(stats.lastPrompt)],
+      ["Suggested files", (stats.lastPrompt.relevantFiles || []).map((file) => file.path).join(", ") || "none"]
+    ]));
   }
 
   if (stats.lastReport) {
-    lines.push(`Last report efficiency: ${stats.lastReport.efficiencyScore == null ? "unknown" : `${stats.lastReport.efficiencyScore}%`}`);
-    lines.push(`Last report measured rules: ${stats.lastReport.measuredRuleCount ?? ((stats.lastReport.followed?.length || 0) + (stats.lastReport.ignored?.length || 0))}`);
-    lines.push(`Last report unknown rules: ${stats.lastReport.unknownRuleCount ?? (stats.lastReport.unknown?.length || 0)}`);
-    lines.push(`Last report unmeasurable rules: ${stats.lastReport.unmeasurableRuleCount ?? (stats.lastReport.unmeasurable?.length || 0)}`);
-    const changed = stats.lastReport.changedFiles?.join(", ");
-    if (changed) lines.push(`Last changed files: ${changed}`);
+    lines.push(section("Last Report"));
+    lines.push(table(["Metric", "Value"], [
+      ["Efficiency", stats.lastReport.efficiencyScore == null ? "unknown" : `${stats.lastReport.efficiencyScore}%`],
+      ["Measured rules", stats.lastReport.measuredRuleCount ?? ((stats.lastReport.followed?.length || 0) + (stats.lastReport.ignored?.length || 0))],
+      ["Unknown rules", stats.lastReport.unknownRuleCount ?? (stats.lastReport.unknown?.length || 0)],
+      ["Unmeasurable rules", stats.lastReport.unmeasurableRuleCount ?? (stats.lastReport.unmeasurable?.length || 0)],
+      ["Changed files", stats.lastReport.changedFiles?.join(", ") || "none"]
+    ]));
   }
 
   return lines.join("\n");
@@ -123,8 +138,3 @@ function formatAverageEfficiency(stats) {
 function scheduledRuleCount(prompt) {
   return (prompt.scheduled?.highRules?.length || 0) + (prompt.scheduled?.midRules?.length || 0);
 }
-
-function truncateLine(value, max) {
-  const normalized = String(value).replace(/\s+/g, " ").trim();
-  return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
-}

package/plugins/ctx/lib/terminal-ui.js

@@ -0,0 +1,22 @@
+export function section(title) {
+  return `\n${title}\n${"-".repeat(title.length)}`;
+}
+
+export function table(headers, rows) {
+  const normalizedRows = rows.map((row) => row.map((cell) => String(cell ?? "")));
+  const widths = headers.map((header, index) => Math.max(
+    String(header).length,
+    ...normalizedRows.map((row) => row[index]?.length || 0)
+  ));
+  const formatRow = (row) => row.map((cell, index) => String(cell ?? "").padEnd(widths[index])).join("  ");
+  return [
+    formatRow(headers),
+    widths.map((width) => "-".repeat(width)).join("  "),
+    ...normalizedRows.map(formatRow)
+  ].join("\n");
+}
+
+export function truncateCell(value, max = 80) {
+  const normalized = String(value || "").replace(/\s+/g, " ").trim();
+  return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
+}