selftune 0.1.0 → 0.1.4

package/cli/selftune/index.ts

@@ -13,6 +13,9 @@
  *   selftune rollback [options]       — Rollback a skill to its pre-evolution state
  *   selftune watch [options]          — Monitor post-deploy skill health
  *   selftune doctor                   — Run health checks
+ *   selftune status                   — Show skill health summary
+ *   selftune last                     — Show last session details
+ *   selftune dashboard [options]      — Open visual data dashboard
  */
 
 const command = process.argv[2];
@@ -34,6 +37,9 @@ Commands:
   rollback           Rollback a skill to its pre-evolution state
   watch              Monitor post-deploy skill health
   doctor             Run health checks
+  status             Show skill health summary
+  last               Show last session details
+  dashboard          Open visual data dashboard
 
 Run 'selftune <command> --help' for command-specific options.`);
   process.exit(0);
@@ -98,6 +104,21 @@ switch (command) {
     process.exit(result.healthy ? 0 : 1);
     break;
   }
+  case "status": {
+    const { cliMain } = await import("./status.js");
+    cliMain();
+    break;
+  }
+  case "last": {
+    const { cliMain } = await import("./last.js");
+    cliMain();
+    break;
+  }
+  case "dashboard": {
+    const { cliMain } = await import("./dashboard.js");
+    cliMain();
+    break;
+  }
   default:
     console.error(`Unknown command: ${command}\nRun 'selftune --help' for available commands.`);
     process.exit(1);

package/cli/selftune/ingestors/codex-rollout.ts

@@ -21,7 +21,7 @@
  *   bun codex-rollout.ts --force
  */
 
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { parseArgs } from "node:util";

package/cli/selftune/ingestors/opencode-ingest.ts

@@ -21,12 +21,12 @@
  */
 
 import { Database } from "bun:sqlite";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { parseArgs } from "node:util";
 import { QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
-import type { QueryLogRecord, SessionTelemetryRecord, SkillUsageRecord } from "../types.js";
+import type { QueryLogRecord, SkillUsageRecord } from "../types.js";
 import { appendJsonl, loadMarker, saveMarker } from "../utils/jsonl.js";
 
 const XDG_DATA_HOME = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");

package/cli/selftune/init.ts

@@ -7,7 +7,7 @@
  * the result to ~/.selftune/config.json.
  *
  * Usage:
- *   selftune init [--agent <type>] [--cli-path <path>] [--llm-mode <mode>] [--force]
+ *   selftune init [--agent <type>] [--cli-path <path>] [--force]
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -40,6 +40,16 @@ const VALID_AGENT_TYPES: SelftuneConfig["agent_type"][] = [
   "unknown",
 ];
 
+const AGENT_TYPE_CLI_MAP: Record<string, string> = {
+  claude_code: "claude",
+  codex: "codex",
+  opencode: "opencode",
+};
+
+function agentTypeToCli(agentType: string): string | null {
+  return AGENT_TYPE_CLI_MAP[agentType] ?? null;
+}
+
 export function detectAgentType(
   override?: string,
   homeOverride?: string,
@@ -95,34 +105,11 @@ export function determineCliPath(override?: string): string {
 /**
  * Determine LLM mode and agent CLI based on available signals.
  */
-export function determineLlmMode(
-  agentCli: string | null,
-  hasApiKey?: boolean,
-  modeOverride?: string,
-): { llm_mode: "agent" | "api"; agent_cli: string | null } {
-  const detectedAgent = agentCli;
-  const validModes = ["agent", "api"] as const;
-  if (modeOverride && !validModes.includes(modeOverride as (typeof validModes)[number])) {
-    throw new Error(
-      `Invalid --llm-mode "${modeOverride}". Allowed values: ${validModes.join(", ")}`,
-    );
-  }
-  const resolvedMode = modeOverride as "agent" | "api" | undefined;
-
-  if (resolvedMode) {
-    return { llm_mode: resolvedMode, agent_cli: detectedAgent };
-  }
-
-  if (detectedAgent) {
-    return { llm_mode: "agent", agent_cli: detectedAgent };
-  }
-
-  if (hasApiKey) {
-    return { llm_mode: "api", agent_cli: null };
-  }
-
-  // Fallback: agent mode with null cli (will need setup)
-  return { llm_mode: "agent", agent_cli: null };
+export function determineLlmMode(agentCli: string | null): {
+  llm_mode: "agent";
+  agent_cli: string | null;
+} {
+  return { llm_mode: "agent", agent_cli: agentCli };
 }
 
 // ---------------------------------------------------------------------------
@@ -170,7 +157,6 @@ export interface InitOptions {
   force: boolean;
   agentOverride?: string;
   cliPathOverride?: string;
-  llmModeOverride?: string;
   homeDir?: string;
 }
 
@@ -203,12 +189,17 @@ export function runInit(opts: InitOptions): SelftuneConfig {
   // Resolve CLI path
   const cliPath = determineCliPath(opts.cliPathOverride);
 
-  // Detect agent CLI
-  const agentCli = detectAgent();
+  // Detect agent CLI — when an override is provided, fall back to mapped CLI
+  // name so init works in test/CI environments without agent binaries in PATH
+  const agentCli = detectAgent() ?? (opts.agentOverride ? agentTypeToCli(agentType) : null);
+  if (!agentCli) {
+    throw new Error(
+      "No supported agent CLI detected (claude, codex, opencode). Install one, then rerun `selftune init`.",
+    );
+  }
 
   // Determine LLM mode
-  const hasApiKey = Boolean(process.env.ANTHROPIC_API_KEY);
-  const { llm_mode, agent_cli } = determineLlmMode(agentCli, hasApiKey, opts.llmModeOverride);
+  const { llm_mode, agent_cli } = determineLlmMode(agentCli);
 
   // Check hooks (Claude Code only)
   const home = opts.homeDir ?? homedir();
@@ -240,7 +231,6 @@ export async function cliMain(): Promise<void> {
     options: {
       agent: { type: "string" },
       "cli-path": { type: "string" },
-      "llm-mode": { type: "string" },
       force: { type: "boolean", default: false },
     },
     strict: true,
@@ -271,7 +261,6 @@ export async function cliMain(): Promise<void> {
     force,
     agentOverride: values.agent,
     cliPathOverride: values["cli-path"],
-    llmModeOverride: values["llm-mode"],
   });
 
   console.log(JSON.stringify(config, null, 2));

package/cli/selftune/last.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env bun
+/**
+ * Quick insight from the most recent session.
+ * Lightweight, no LLM calls.
+ */
+
+import { QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "./constants.js";
+import type { QueryLogRecord, SessionTelemetryRecord, SkillUsageRecord } from "./types.js";
+import { readJsonl } from "./utils/jsonl.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface LastSessionInsight {
+  sessionId: string;
+  timestamp: string;
+  skillsTriggered: string[];
+  unmatchedQueries: string[];
+  errors: number;
+  toolCalls: number;
+  recommendation: string;
+}
+
+// ---------------------------------------------------------------------------
+// Pure logic
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute insight from the most recent session.
+ * Returns null when no telemetry data exists.
+ */
+export function computeLastInsight(
+  telemetry: SessionTelemetryRecord[],
+  skillRecords: SkillUsageRecord[],
+  queryRecords: QueryLogRecord[],
+): LastSessionInsight | null {
+  if (telemetry.length === 0) return null;
+
+  // Find most recent telemetry record
+  const sorted = [...telemetry].sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime(),
+  );
+  const latest = sorted[0];
+  const sessionId = latest.session_id;
+
+  // Skills triggered: unique skill names where triggered=true AND session matches
+  const triggeredSkillQueries = new Set<string>();
+  const skillsTriggered = [
+    ...new Set(
+      skillRecords
+        .filter((r) => r.session_id === sessionId && r.triggered)
+        .map((r) => {
+          triggeredSkillQueries.add(r.query.toLowerCase().trim());
+          return r.skill_name;
+        }),
+    ),
+  ];
+
+  // Unmatched queries: session queries whose text does NOT appear in any triggered skill record
+  const sessionQueries = queryRecords.filter((r) => r.session_id === sessionId);
+  const unmatchedQueries = sessionQueries
+    .filter((q) => !triggeredSkillQueries.has(q.query.toLowerCase().trim()))
+    .map((q) => q.query);
+
+  const errors = latest.errors_encountered;
+  const toolCalls = latest.total_tool_calls;
+
+  // Contextual recommendation
+  let recommendation: string;
+  const unmatched = unmatchedQueries.length;
+  if (unmatched > 0) {
+    recommendation = `${unmatched} queries had no skill match. Run 'selftune evals --list-skills' to investigate.`;
+  } else if (errors > 0) {
+    recommendation = `${errors} errors encountered. Check logs for details.`;
+  } else {
+    recommendation = "All queries matched skills. System is operating well.";
+  }
+
+  return {
+    sessionId,
+    timestamp: latest.timestamp,
+    skillsTriggered,
+    unmatchedQueries,
+    errors,
+    toolCalls,
+    recommendation,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+/** Format an insight as a human-readable plain-text summary. */
+export function formatInsight(insight: LastSessionInsight): string {
+  const date = new Date(insight.timestamp);
+  const month = date.toLocaleString("en-US", { month: "short" });
+  const day = date.getDate();
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const dateStr = `${month} ${day}, ${hours}:${minutes}`;
+
+  const lines: string[] = [];
+  lines.push(`Last session: ${insight.sessionId} (${dateStr})`);
+  lines.push("");
+  lines.push(`  Skills triggered:  ${insight.skillsTriggered.join(", ") || "none"}`);
+  lines.push(`  Unmatched queries: ${insight.unmatchedQueries.length}`);
+  for (const q of insight.unmatchedQueries) {
+    lines.push(`    \u00B7 "${q}"`);
+  }
+  lines.push(`  Errors: ${insight.errors}`);
+  lines.push(`  Tool calls: ${insight.toolCalls}`);
+  lines.push("");
+  lines.push(`  \u2192 ${insight.recommendation}`);
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+
+/** CLI main: reads logs, prints insight. */
+export function cliMain(): void {
+  const telemetry = readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG);
+  const skillRecords = readJsonl<SkillUsageRecord>(SKILL_LOG);
+  const queryRecords = readJsonl<QueryLogRecord>(QUERY_LOG);
+
+  const insight = computeLastInsight(telemetry, skillRecords, queryRecords);
+  if (!insight) {
+    console.log("No session data found.");
+    process.exit(0);
+  }
+
+  console.log(formatInsight(insight));
+  process.exit(0);
+}

package/cli/selftune/observability.ts

@@ -16,7 +16,7 @@ import { LOG_DIR, REQUIRED_FIELDS, SELFTUNE_CONFIG_PATH } from "./constants.js";
 import type { DoctorResult, HealthCheck, HealthStatus, SelftuneConfig } from "./types.js";
 
 const VALID_AGENT_TYPES = new Set(["claude_code", "codex", "opencode", "unknown"]);
-const VALID_LLM_MODES = new Set(["agent", "api"]);
+const VALID_LLM_MODES = new Set(["agent"]);
 
 const LOG_FILES: Record<string, string> = {
   session_telemetry: join(LOG_DIR, "session_telemetry_log.jsonl"),

package/cli/selftune/status.ts

@@ -0,0 +1,318 @@
+/**
+ * selftune status — Skill health summary CLI command.
+ *
+ * Exports:
+ *  - computeStatus()  (pure function, deterministic)
+ *  - formatStatus()   (colored terminal output)
+ *  - cliMain()        (reads logs, runs doctor, prints output)
+ */
+
+import { EVOLUTION_AUDIT_LOG, QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "./constants.js";
+import { computeMonitoringSnapshot } from "./monitoring/watch.js";
+import { doctor } from "./observability.js";
+import type {
+  DoctorResult,
+  EvolutionAuditEntry,
+  MonitoringSnapshot,
+  QueryLogRecord,
+  SessionTelemetryRecord,
+  SkillUsageRecord,
+} from "./types.js";
+import { readJsonl } from "./utils/jsonl.js";
+
+// ---------------------------------------------------------------------------
+// Result types
+// ---------------------------------------------------------------------------
+
+export interface SkillStatus {
+  name: string;
+  passRate: number | null;
+  trend: "up" | "down" | "stable" | "unknown";
+  missedQueries: number;
+  status: "HEALTHY" | "REGRESSED" | "NO DATA";
+  snapshot: MonitoringSnapshot | null;
+}
+
+export interface StatusResult {
+  skills: SkillStatus[];
+  unmatchedQueries: number;
+  pendingProposals: number;
+  lastSession: string | null;
+  system: {
+    healthy: boolean;
+    pass: number;
+    fail: number;
+    warn: number;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DEFAULT_WINDOW_SESSIONS = 20;
+const DEFAULT_BASELINE_PASS_RATE = 0.5;
+
+// ---------------------------------------------------------------------------
+// computeStatus — pure function
+// ---------------------------------------------------------------------------
+
+export function computeStatus(
+  telemetry: SessionTelemetryRecord[],
+  skillRecords: SkillUsageRecord[],
+  queryRecords: QueryLogRecord[],
+  auditEntries: EvolutionAuditEntry[],
+  doctorResult: DoctorResult,
+): StatusResult {
+  // Derive unique skill names from skill records
+  const skillNames = [...new Set(skillRecords.map((r) => r.skill_name))];
+
+  // Build per-skill status
+  const skills: SkillStatus[] = skillNames.map((skillName) => {
+    const skillSpecificRecords = skillRecords.filter((r) => r.skill_name === skillName);
+    const triggeredRecords = skillSpecificRecords.filter((r) => r.triggered);
+
+    // Get baseline from last deployed proposal
+    const lastDeployed = getLastDeployedProposalFromEntries(auditEntries, skillName);
+    const baselinePassRate = lastDeployed?.eval_snapshot?.pass_rate ?? DEFAULT_BASELINE_PASS_RATE;
+
+    // Compute monitoring snapshot
+    const snapshot = computeMonitoringSnapshot(
+      skillName,
+      telemetry,
+      skillRecords,
+      queryRecords,
+      DEFAULT_WINDOW_SESSIONS,
+      baselinePassRate,
+    );
+
+    // Determine if there's any meaningful data
+    const totalQueries = queryRecords.length;
+    const hasData = triggeredRecords.length > 0 || totalQueries > 0;
+
+    // Compute pass rate (null if no data)
+    let passRate: number | null = null;
+    if (hasData && totalQueries > 0) {
+      passRate = snapshot.pass_rate;
+    }
+
+    // Determine trend: compare first-half vs second-half pass rates
+    const trend = computeTrend(skillSpecificRecords);
+
+    // Count missed queries for this skill (queries where skill was checked but not triggered)
+    const missedQueries = skillSpecificRecords.filter((r) => !r.triggered).length;
+
+    // Determine status
+    let status: "HEALTHY" | "REGRESSED" | "NO DATA";
+    if (!hasData || passRate === null) {
+      status = "NO DATA";
+    } else if (snapshot.regression_detected) {
+      status = "REGRESSED";
+    } else {
+      status = "HEALTHY";
+    }
+
+    return { name: skillName, passRate, trend, missedQueries, status, snapshot };
+  });
+
+  // Sort: REGRESSED first, then HEALTHY, then NO DATA
+  const statusOrder = { REGRESSED: 0, HEALTHY: 1, "NO DATA": 2 };
+  skills.sort((a, b) => statusOrder[a.status] - statusOrder[b.status]);
+
+  // Unmatched queries: queries whose text appears in zero triggered skill_usage_log entries
+  const triggeredQueryTexts = new Set(
+    skillRecords.filter((r) => r.triggered).map((r) => r.query.toLowerCase().trim()),
+  );
+  const unmatchedQueries = queryRecords.filter(
+    (q) => !triggeredQueryTexts.has(q.query.toLowerCase().trim()),
+  ).length;
+
+  // Pending proposals: audit entries with action=created/validated that have
+  // no later deployed/rejected/rolled_back for same proposal_id
+  const terminalActions = new Set(["deployed", "rejected", "rolled_back"]);
+  const proposalIds = [...new Set(auditEntries.map((e) => e.proposal_id))];
+  const pendingProposals = proposalIds.filter((pid) => {
+    const entries = auditEntries.filter((e) => e.proposal_id === pid);
+    const hasTerminal = entries.some((e) => terminalActions.has(e.action));
+    const hasCreatedOrValidated = entries.some(
+      (e) => e.action === "created" || e.action === "validated",
+    );
+    return hasCreatedOrValidated && !hasTerminal;
+  }).length;
+
+  // Last session timestamp
+  let lastSession: string | null = null;
+  if (telemetry.length > 0) {
+    lastSession = telemetry.reduce(
+      (latest, t) => (t.timestamp > latest ? t.timestamp : latest),
+      telemetry[0].timestamp,
+    );
+  }
+
+  // System health from doctor result
+  const system = {
+    healthy: doctorResult.healthy,
+    pass: doctorResult.summary.pass,
+    fail: doctorResult.summary.fail,
+    warn: doctorResult.summary.warn,
+  };
+
+  return { skills, unmatchedQueries, pendingProposals, lastSession, system };
+}
+
+// ---------------------------------------------------------------------------
+// Trend computation
+// ---------------------------------------------------------------------------
+
+function computeTrend(skillRecords: SkillUsageRecord[]): "up" | "down" | "stable" | "unknown" {
+  if (skillRecords.length < 2) return "unknown";
+
+  // Sort by timestamp
+  const sorted = [...skillRecords].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  const mid = Math.floor(sorted.length / 2);
+
+  const firstHalf = sorted.slice(0, mid);
+  const secondHalf = sorted.slice(mid);
+
+  const firstRate =
+    firstHalf.length > 0 ? firstHalf.filter((r) => r.triggered).length / firstHalf.length : 0;
+  const secondRate =
+    secondHalf.length > 0 ? secondHalf.filter((r) => r.triggered).length / secondHalf.length : 0;
+
+  if (secondRate > firstRate) return "up";
+  if (secondRate < firstRate) return "down";
+  return "stable";
+}
+
+// ---------------------------------------------------------------------------
+// Helper: get last deployed proposal from in-memory audit entries
+// ---------------------------------------------------------------------------
+
+function getLastDeployedProposalFromEntries(
+  entries: EvolutionAuditEntry[],
+  skillName: string,
+): EvolutionAuditEntry | null {
+  const needle = skillName.toLowerCase();
+  // Use word-boundary regex to avoid substring false positives (e.g. "api" matching "rapid-api").
+  // Note: skillName originates from internal JSONL logs, not user input, so ReDoS risk is minimal.
+  const pattern = new RegExp(`\\b${needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i");
+  const deployed = entries.filter((e) => e.action === "deployed" && pattern.test(e.details ?? ""));
+  return deployed.length > 0 ? deployed[deployed.length - 1] : null;
+}
+
+// ---------------------------------------------------------------------------
+// formatStatus — colored terminal output
+// ---------------------------------------------------------------------------
+
+const TREND_SYMBOLS: Record<string, string> = {
+  up: "\u2191",
+  down: "\u2193",
+  stable: "\u2192",
+  unknown: "?",
+};
+
+export function formatStatus(result: StatusResult): string {
+  const noColor = !!process.env.NO_COLOR;
+
+  const green = noColor ? (s: string) => s : (s: string) => colorize(s, "#788c5d");
+  const red = noColor ? (s: string) => s : (s: string) => colorize(s, "#cc4444");
+  const amber = noColor ? (s: string) => s : (s: string) => colorize(s, "#c49133");
+
+  const lines: string[] = [];
+  lines.push("selftune status");
+  lines.push("\u2550".repeat(15));
+  lines.push("");
+
+  // Skills table
+  const skillCount = result.skills.length;
+  lines.push(
+    `Skills (${skillCount})${" ".repeat(36 - `Skills (${skillCount})`.length)}Recent data`,
+  );
+  lines.push("  Name            Pass Rate  Trend  Missed  Status");
+
+  for (const skill of result.skills) {
+    const name = skill.name.padEnd(16);
+    const passRate =
+      skill.passRate !== null
+        ? `${Math.round(skill.passRate * 100)}%`.padEnd(11)
+        : "\u2014".padEnd(11);
+    const trend = TREND_SYMBOLS[skill.trend].padEnd(7);
+    const missed = String(skill.missedQueries).padEnd(8);
+    const statusText =
+      skill.status === "REGRESSED"
+        ? red(skill.status)
+        : skill.status === "HEALTHY"
+          ? green(skill.status)
+          : amber(skill.status);
+    lines.push(`  ${name}${passRate}${trend}${missed}${statusText}`);
+  }
+
+  lines.push("");
+
+  // Summary stats
+  lines.push(`Unmatched queries:  ${result.unmatchedQueries}`);
+  lines.push(`Pending proposals:  ${result.pendingProposals}`);
+
+  // Last session
+  if (result.lastSession) {
+    const d = new Date(result.lastSession);
+    const formatted = d.toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+    });
+    const time = d.toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+    });
+    lines.push(`Last session:       ${formatted}, ${time}`);
+  } else {
+    lines.push("Last session:       \u2014");
+  }
+
+  // System health
+  const { pass, fail, warn, healthy } = result.system;
+  const healthLabel = healthy ? green("HEALTHY") : red("UNHEALTHY");
+  lines.push(`System:             ${healthLabel} (${pass} pass, ${fail} fail, ${warn} warn)`);
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Terminal color helper using ANSI escapes
+// ---------------------------------------------------------------------------
+
+function colorize(text: string, hex: string): string {
+  // Expand 3-digit hex (#rgb) to 6-digit (#rrggbb)
+  const color =
+    hex.length === 4 && hex.startsWith("#")
+      ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}`
+      : hex;
+  const r = Number.parseInt(color.slice(1, 3), 16);
+  const g = Number.parseInt(color.slice(3, 5), 16);
+  const b = Number.parseInt(color.slice(5, 7), 16);
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+
+// ---------------------------------------------------------------------------
+// cliMain — reads logs, runs doctor, prints output
+// ---------------------------------------------------------------------------
+
+export function cliMain(): void {
+  try {
+    const telemetry = readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG);
+    const skillRecords = readJsonl<SkillUsageRecord>(SKILL_LOG);
+    const queryRecords = readJsonl<QueryLogRecord>(QUERY_LOG);
+    const auditEntries = readJsonl<EvolutionAuditEntry>(EVOLUTION_AUDIT_LOG);
+    const doctorResult = doctor();
+
+    const result = computeStatus(telemetry, skillRecords, queryRecords, auditEntries, doctorResult);
+    const output = formatStatus(result);
+    console.log(output);
+    process.exit(0);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`selftune status failed: ${message}`);
+    process.exit(1);
+  }
+}

package/cli/selftune/types.ts

@@ -9,7 +9,7 @@
 export interface SelftuneConfig {
   agent_type: "claude_code" | "codex" | "opencode" | "unknown";
   cli_path: string;
-  llm_mode: "agent" | "api";
+  llm_mode: "agent";
   agent_cli: string | null;
   hooks_installed: boolean;
   initialized_at: string;