selftune 0.2.0 → 0.2.2

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

@@ -25,8 +25,24 @@ 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, SkillUsageRecord } from "../types.js";
+import { CANONICAL_LOG, QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
+import {
+  appendCanonicalRecords,
+  buildCanonicalExecutionFact,
+  buildCanonicalPrompt,
+  buildCanonicalSession,
+  buildCanonicalSkillInvocation,
+  type CanonicalBaseInput,
+  deriveInvocationMode,
+  derivePromptId,
+  deriveSkillInvocationId,
+} from "../normalization.js";
+import type {
+  CanonicalRecord,
+  QueryLogRecord,
+  SessionTelemetryRecord,
+  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");
@@ -48,6 +64,26 @@ const OPENCODE_SKILLS_DIRS = [
   join(homedir(), ".config", "opencode", "skills"),
 ];
 
+interface TriggeredSkillDetection {
+  skill_name: string;
+  has_skill_md_read: boolean;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function containsWholeSkillMention(text: string, skillName: string): boolean {
+  const trimmedSkillName = skillName.trim();
+  if (!text || !trimmedSkillName) return false;
+
+  const pattern = new RegExp(
+    `(^|[^A-Za-z0-9_])${escapeRegExp(trimmedSkillName)}([^A-Za-z0-9_]|$)`,
+    "i",
+  );
+  return pattern.test(text);
+}
+
 /** Return skill names from OpenCode skill directories. */
 export function findSkillNames(dirs: string[] = OPENCODE_SKILLS_DIRS): Set<string> {
   const names = new Set<string>();
@@ -79,9 +115,12 @@ export interface ParsedSession {
   total_tool_calls: number;
   bash_commands: string[];
   skills_triggered: string[];
+  skill_detections?: TriggeredSkillDetection[];
   assistant_turns: number;
   errors_encountered: number;
   transcript_chars: number;
+  /** True when local session JSON is metadata-only (no embedded messages). */
+  is_metadata_only?: boolean;
 }
 
 /** Return a human-readable schema summary for --show-schema. */
@@ -202,10 +241,24 @@ export function readSessionsFromSqlite(
     let firstUserQuery = "";
     const toolCalls: Record<string, number> = {};
     const bashCommands: string[] = [];
-    const skillsTriggered: string[] = [];
+    const skillDetections = new Map<string, TriggeredSkillDetection>();
     let errors = 0;
     let assistantTurns = 0;
 
+    const noteSkillDetection = (skillName: string, hasSkillMdRead: boolean): void => {
+      const normalizedSkillName = skillName.trim();
+      if (!normalizedSkillName) return;
+      const existing = skillDetections.get(normalizedSkillName);
+      if (existing) {
+        existing.has_skill_md_read = existing.has_skill_md_read || hasSkillMdRead;
+        return;
+      }
+      skillDetections.set(normalizedSkillName, {
+        skill_name: normalizedSkillName,
+        has_skill_md_read: hasSkillMdRead,
+      });
+    };
+
     for (const msg of msgRows) {
       const role = (msg.role as string) ?? "";
       const blocks = normalizeContent(msg.content ?? "[]");
@@ -251,9 +304,7 @@ export function readSessionsFromSqlite(
               const filePath = (inp.file_path as string) ?? (inp.path as string) ?? "";
               if (basename(filePath).toUpperCase() === "SKILL.MD") {
                 const skillName = basename(join(filePath, ".."));
-                if (!skillsTriggered.includes(skillName)) {
-                  skillsTriggered.push(skillName);
-                }
+                noteSkillDetection(skillName, true);
               }
             }
           }
@@ -271,8 +322,8 @@ export function readSessionsFromSqlite(
           // Check text content for skill name mentions
           const textContent = (block.text as string) ?? "";
           for (const skillName of skillNames) {
-            if (textContent.includes(skillName) && !skillsTriggered.includes(skillName)) {
-              skillsTriggered.push(skillName);
+            if (containsWholeSkillMention(textContent, skillName)) {
+              noteSkillDetection(skillName, false);
             }
           }
         }
@@ -299,7 +350,8 @@ export function readSessionsFromSqlite(
       tool_calls: toolCalls,
       total_tool_calls: Object.values(toolCalls).reduce((a, b) => a + b, 0),
       bash_commands: bashCommands,
-      skills_triggered: skillsTriggered,
+      skills_triggered: [...skillDetections.values()].map((entry) => entry.skill_name),
+      skill_detections: [...skillDetections.values()],
       assistant_turns: assistantTurns,
       errors_encountered: errors,
       transcript_chars: 0,
@@ -349,13 +401,30 @@ export function readSessionsFromJsonFiles(
     const timestamp = new Date(created * 1000).toISOString();
     const messages = (data.messages as Array<Record<string, unknown>>) ?? [];
 
+    // Detect metadata-only session files (no message bodies)
+    const isMetadataOnly = messages.length === 0;
+
     let firstUserQuery = "";
     const toolCalls: Record<string, number> = {};
     const bashCommands: string[] = [];
-    const skillsTriggered: string[] = [];
+    const skillDetections = new Map<string, TriggeredSkillDetection>();
     let errors = 0;
     let turns = 0;
 
+    const noteSkillDetection = (skillName: string, hasSkillMdRead: boolean): void => {
+      const normalizedSkillName = skillName.trim();
+      if (!normalizedSkillName) return;
+      const existing = skillDetections.get(normalizedSkillName);
+      if (existing) {
+        existing.has_skill_md_read = existing.has_skill_md_read || hasSkillMdRead;
+        return;
+      }
+      skillDetections.set(normalizedSkillName, {
+        skill_name: normalizedSkillName,
+        has_skill_md_read: hasSkillMdRead,
+      });
+    };
+
     for (const msg of messages) {
       const role = (msg.role as string) ?? "";
       const blocks = normalizeContent(msg.content ?? []);
@@ -385,17 +454,15 @@ export function readSessionsFromJsonFiles(
               const fp = (inp.file_path as string) ?? "";
               if (basename(fp).toUpperCase() === "SKILL.MD") {
                 const sn = basename(join(fp, ".."));
-                if (!skillsTriggered.includes(sn)) {
-                  skillsTriggered.push(sn);
-                }
+                noteSkillDetection(sn, true);
               }
             }
           }
 
           const text = (block.text as string) ?? "";
           for (const skillName of skillNames) {
-            if (text.includes(skillName) && !skillsTriggered.includes(skillName)) {
-              skillsTriggered.push(skillName);
+            if (containsWholeSkillMention(text, skillName)) {
+              noteSkillDetection(skillName, false);
             }
           }
         }
@@ -422,10 +489,12 @@ export function readSessionsFromJsonFiles(
       tool_calls: toolCalls,
       total_tool_calls: Object.values(toolCalls).reduce((a, b) => a + b, 0),
       bash_commands: bashCommands,
-      skills_triggered: skillsTriggered,
+      skills_triggered: [...skillDetections.values()].map((entry) => entry.skill_name),
+      skill_detections: [...skillDetections.values()],
       assistant_turns: turns,
       errors_encountered: errors,
       transcript_chars: statSync(filePath).size,
+      is_metadata_only: isMetadataOnly,
     });
   }
 
@@ -439,6 +508,7 @@ export function writeSession(
   queryLogPath: string = QUERY_LOG,
   telemetryLogPath: string = TELEMETRY_LOG,
   skillLogPath: string = SKILL_LOG,
+  canonicalLogPath: string = CANONICAL_LOG,
 ): void {
   const { query: prompt, session_id: sessionId, skills_triggered: skills } = session;
 
@@ -460,7 +530,21 @@ export function writeSession(
     appendJsonl(queryLogPath, queryRecord, "all_queries");
   }
 
-  const { query: _q, ...telemetry } = session;
+  const telemetry: SessionTelemetryRecord = {
+    timestamp: session.timestamp,
+    session_id: session.session_id,
+    cwd: session.cwd,
+    transcript_path: session.transcript_path,
+    tool_calls: session.tool_calls,
+    total_tool_calls: session.total_tool_calls,
+    bash_commands: session.bash_commands,
+    skills_triggered: session.skills_triggered,
+    assistant_turns: session.assistant_turns,
+    errors_encountered: session.errors_encountered,
+    transcript_chars: session.transcript_chars,
+    last_user_query: session.last_user_query,
+    source: session.source,
+  };
   appendJsonl(telemetryLogPath, telemetry, "session_telemetry");
 
   for (const skillName of skills) {
@@ -475,6 +559,98 @@ export function writeSession(
     };
     appendJsonl(skillLogPath, skillRecord, "skill_usage");
   }
+
+  // --- Canonical normalization records (additive) ---
+  const canonicalRecords = buildCanonicalRecordsFromOpenCode(session);
+  appendCanonicalRecords(canonicalRecords, canonicalLogPath);
+}
+
+/** Build canonical records from a parsed OpenCode session. */
+export function buildCanonicalRecordsFromOpenCode(session: ParsedSession): CanonicalRecord[] {
+  const records: CanonicalRecord[] = [];
+  const sourceKind = session.is_metadata_only ? ("replayed" as const) : ("replayed" as const);
+  const baseInput: CanonicalBaseInput = {
+    platform: "opencode",
+    capture_mode: "batch_ingest",
+    source_session_kind: sourceKind,
+    session_id: session.session_id,
+    raw_source_ref: {
+      path: session.transcript_path,
+      event_type: session.source,
+      metadata: session.is_metadata_only ? { metadata_only: true } : undefined,
+    },
+  };
+
+  records.push(
+    buildCanonicalSession({
+      ...baseInput,
+      started_at: session.timestamp,
+      workspace_path: session.cwd || undefined,
+    }),
+  );
+
+  const promptEmitted = Boolean(
+    session.query && session.query.length >= 4 && !session.is_metadata_only,
+  );
+  const promptId = promptEmitted ? derivePromptId(session.session_id, 0) : undefined;
+
+  if (promptId) {
+    records.push(
+      buildCanonicalPrompt({
+        ...baseInput,
+        prompt_id: promptId,
+        occurred_at: session.timestamp,
+        prompt_text: session.query,
+        prompt_index: 0,
+      }),
+    );
+  }
+
+  const skillDetections =
+    session.skill_detections ??
+    session.skills_triggered.map((skillName) => ({
+      skill_name: skillName,
+      has_skill_md_read: false,
+    }));
+
+  for (let i = 0; i < skillDetections.length; i++) {
+    const detection = skillDetections[i];
+    const skillName = detection.skill_name;
+    const { invocation_mode, confidence } = deriveInvocationMode({
+      has_skill_md_read: detection.has_skill_md_read,
+      is_text_mention_only: !detection.has_skill_md_read,
+    });
+    records.push(
+      buildCanonicalSkillInvocation({
+        ...baseInput,
+        skill_invocation_id: deriveSkillInvocationId(session.session_id, skillName, i),
+        occurred_at: session.timestamp,
+        matched_prompt_id: promptId,
+        skill_name: skillName,
+        skill_path: `(opencode:${skillName})`,
+        invocation_mode,
+        triggered: true,
+        confidence,
+      }),
+    );
+  }
+
+  if (!session.is_metadata_only) {
+    records.push(
+      buildCanonicalExecutionFact({
+        ...baseInput,
+        occurred_at: session.timestamp,
+        prompt_id: promptId,
+        tool_calls_json: session.tool_calls,
+        total_tool_calls: session.total_tool_calls,
+        bash_commands_redacted: session.bash_commands,
+        assistant_turns: session.assistant_turns,
+        errors_encountered: session.errors_encountered,
+      }),
+    );
+  }
+
+  return records;
 }
 
 // --- CLI main ---

package/cli/selftune/init.ts

@@ -8,16 +8,25 @@
  *
  * Usage:
  *   selftune init [--agent <type>] [--cli-path <path>] [--force]
+ *   selftune init --enable-autonomy [--schedule-format cron|launchd|systemd]
  */
 
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
-import { SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
+import { CLAUDE_CODE_HOOK_KEYS, SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
 import type { SelftuneConfig } from "./types.js";
+import { hookKeyHasSelftuneEntry } from "./utils/hooks.js";
 import { detectAgent } from "./utils/llm-call.js";
 
 // ---------------------------------------------------------------------------
@@ -124,8 +133,6 @@ export function determineLlmMode(agentCli: string | null): {
 // Hook detection (Claude Code only)
 // ---------------------------------------------------------------------------
 
-const REQUIRED_HOOK_KEYS = ["prompt-submit", "post-tool-use", "session-stop"] as const;
-
 /**
  * Check if the selftune hooks are configured in Claude Code settings.
  */
@@ -138,15 +145,10 @@ export function checkClaudeCodeHooks(settingsPath: string): boolean {
     const hooks = settings?.hooks;
     if (!hooks || typeof hooks !== "object") return false;
 
-    for (const key of REQUIRED_HOOK_KEYS) {
-      const entries = hooks[key];
-      if (!Array.isArray(entries) || entries.length === 0) return false;
-      // Check that at least one entry references selftune
-      const hasSelftune = entries.some(
-        (e: { command?: string }) =>
-          typeof e.command === "string" && e.command.includes("selftune"),
-      );
-      if (!hasSelftune) return false;
+    for (const key of CLAUDE_CODE_HOOK_KEYS) {
+      if (!hookKeyHasSelftuneEntry(hooks, key)) {
+        return false;
+      }
     }
 
     return true;
@@ -155,6 +157,155 @@ export function checkClaudeCodeHooks(settingsPath: string): boolean {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Hook installation (Claude Code only)
+// ---------------------------------------------------------------------------
+
+/** Bundled settings snippet (ships with the npm package). */
+const SETTINGS_SNIPPET_PATH = resolve(
+  dirname(import.meta.path),
+  "..",
+  "..",
+  "skill",
+  "settings_snippet.json",
+);
+
+/**
+ * Install selftune hooks into ~/.claude/settings.json by merging entries
+ * from the bundled settings_snippet.json.
+ *
+ * - Creates settings.json if it does not exist
+ * - Creates the hooks section if it does not exist
+ * - Only adds hook entries for keys that don't already have a selftune entry
+ * - Never overwrites existing user hooks
+ *
+ * Returns the list of hook keys that were added.
+ */
+export function installClaudeCodeHooks(options?: {
+  settingsPath?: string;
+  snippetPath?: string;
+  cliPath?: string;
+}): string[] {
+  const settingsPath = options?.settingsPath ?? join(homedir(), ".claude", "settings.json");
+  const snippetPath = options?.snippetPath ?? SETTINGS_SNIPPET_PATH;
+
+  // Read the snippet
+  if (!existsSync(snippetPath)) {
+    console.error(`[WARN] Hook snippet not found at ${snippetPath}, skipping hook installation`);
+    return [];
+  }
+
+  let snippet: Record<string, unknown>;
+  try {
+    snippet = JSON.parse(readFileSync(snippetPath, "utf-8"));
+  } catch {
+    console.error(`[WARN] Failed to parse hook snippet at ${snippetPath}`);
+    return [];
+  }
+
+  const snippetHooks = snippet.hooks as Record<string, unknown[]> | undefined;
+  if (!snippetHooks || typeof snippetHooks !== "object") {
+    console.error("[WARN] Hook snippet has no 'hooks' section");
+    return [];
+  }
+
+  // Read existing settings (or start with empty object)
+  let settings: Record<string, unknown> = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      console.error(`[WARN] Failed to parse ${settingsPath}, starting with empty settings`);
+      settings = {};
+    }
+  }
+
+  // Ensure hooks section exists
+  if (!settings.hooks || typeof settings.hooks !== "object") {
+    settings.hooks = {};
+  }
+  const existingHooks = settings.hooks as Record<string, unknown[]>;
+
+  // Resolve the CLI hooks directory for path substitution
+  const cliPath = options?.cliPath;
+  const hooksDir = cliPath ? `${dirname(cliPath)}/hooks` : null;
+
+  const addedKeys: string[] = [];
+
+  for (const key of Object.keys(snippetHooks)) {
+    // Skip if this key already has a selftune entry
+    if (hookKeyHasSelftuneEntry(existingHooks, key)) {
+      continue;
+    }
+
+    // Get the snippet entries for this key, replacing /PATH/TO/ with actual path
+    let entries = snippetHooks[key];
+    if (hooksDir) {
+      // Deep clone and substitute paths
+      const raw = JSON.stringify(entries).replace(/\/PATH\/TO\/cli\/selftune\/hooks/g, hooksDir);
+      entries = JSON.parse(raw);
+    }
+
+    // Merge: append to existing array or create new one
+    if (Array.isArray(existingHooks[key])) {
+      existingHooks[key] = [...existingHooks[key], ...entries];
+    } else {
+      existingHooks[key] = entries;
+    }
+
+    addedKeys.push(key);
+  }
+
+  if (addedKeys.length > 0) {
+    // Ensure ~/.claude/ directory exists
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+
+  return addedKeys;
+}
+
+// ---------------------------------------------------------------------------
+// Agent file installation
+// ---------------------------------------------------------------------------
+
+/** Bundled agent files directory (ships with the npm package). */
+const BUNDLED_AGENTS_DIR = resolve(dirname(import.meta.path), "..", "..", ".claude", "agents");
+
+/**
+ * Copy bundled agent markdown files to ~/.claude/agents/.
+ * Returns a list of file names that were copied (skips files that already exist
+ * unless `force` is true).
+ */
+export function installAgentFiles(options?: { homeDir?: string; force?: boolean }): string[] {
+  const home = options?.homeDir ?? homedir();
+  const force = options?.force ?? false;
+  const targetDir = join(home, ".claude", "agents");
+
+  if (!existsSync(BUNDLED_AGENTS_DIR)) return [];
+
+  let sourceFiles: string[];
+  try {
+    sourceFiles = readdirSync(BUNDLED_AGENTS_DIR).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+
+  if (sourceFiles.length === 0) return [];
+
+  mkdirSync(targetDir, { recursive: true });
+
+  const copied: string[] = [];
+  for (const file of sourceFiles) {
+    const dest = join(targetDir, file);
+    if (!force && existsSync(dest)) continue;
+    copyFileSync(join(BUNDLED_AGENTS_DIR, file), dest);
+    copied.push(file);
+  }
+
+  return copied;
+}
+
 // ---------------------------------------------------------------------------
 // Workspace type detection
 // ---------------------------------------------------------------------------
@@ -346,6 +497,34 @@ export function runInit(opts: InitOptions): SelftuneConfig {
   mkdirSync(configDir, { recursive: true });
   writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 
+  // Install agent files to ~/.claude/agents/
+  const copiedAgents = installAgentFiles({ homeDir: home, force });
+  if (copiedAgents.length > 0) {
+    console.error(`[INFO] Installed agent files: ${copiedAgents.join(", ")}`);
+  }
+
+  // Auto-install hooks into ~/.claude/settings.json (Claude Code only)
+  if (agentType === "claude_code") {
+    const addedHookKeys = installClaudeCodeHooks({
+      settingsPath,
+      cliPath,
+    });
+    if (addedHookKeys.length > 0) {
+      config.hooks_installed = true;
+      // Re-write config with updated hooks_installed flag
+      writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      console.error(
+        `[INFO] Installed ${addedHookKeys.length} selftune hook(s) into ${settingsPath}: ${addedHookKeys.join(", ")}`,
+      );
+    } else if (!config.hooks_installed) {
+      // Re-check in case hooks were already present
+      config.hooks_installed = checkClaudeCodeHooks(settingsPath);
+      if (config.hooks_installed) {
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      }
+    }
+  }
+
   return config;
 }
 
@@ -359,6 +538,8 @@ export async function cliMain(): Promise<void> {
       agent: { type: "string" },
       "cli-path": { type: "string" },
       force: { type: "boolean", default: false },
+      "enable-autonomy": { type: "boolean", default: false },
+      "schedule-format": { type: "string" },
     },
     strict: true,
   });
@@ -366,9 +547,10 @@ export async function cliMain(): Promise<void> {
   const configDir = SELFTUNE_CONFIG_DIR;
   const configPath = SELFTUNE_CONFIG_PATH;
   const force = values.force ?? false;
+  const enableAutonomy = values["enable-autonomy"] ?? false;
 
   // Check for existing config without force
-  if (!force && existsSync(configPath)) {
+  if (!force && !enableAutonomy && existsSync(configPath)) {
     try {
       const raw = readFileSync(configPath, "utf-8");
       const existing = JSON.parse(raw) as SelftuneConfig;
@@ -418,6 +600,37 @@ export async function cliMain(): Promise<void> {
       total: doctorResult.summary.total,
     }),
   );
+
+  if (enableAutonomy) {
+    try {
+      const { installSchedule } = await import("./schedule.js");
+      const scheduleResult = installSchedule({
+        format: values["schedule-format"],
+      });
+
+      if (!scheduleResult.activated) {
+        console.error(
+          "Failed to activate the autonomous scheduler. Re-run with --schedule-format or use `selftune schedule --install --dry-run` to inspect the generated artifacts first.",
+        );
+        process.exit(1);
+      }
+
+      console.log(
+        JSON.stringify({
+          level: "info",
+          code: "autonomy_enabled",
+          format: scheduleResult.format,
+          activated: scheduleResult.activated,
+          files: scheduleResult.artifacts.map((artifact) => artifact.path),
+        }),
+      );
+    } catch (err) {
+      console.error(
+        `Failed to enable autonomy: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      process.exit(1);
+    }
+  }
 }
 
 // Guard: only run when invoked directly

package/cli/selftune/last.ts

@@ -4,9 +4,14 @@
  * Lightweight, no LLM calls.
  */
 
-import { QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "./constants.js";
+import { QUERY_LOG, TELEMETRY_LOG } from "./constants.js";
 import type { QueryLogRecord, SessionTelemetryRecord, SkillUsageRecord } from "./types.js";
 import { readJsonl } from "./utils/jsonl.js";
+import {
+  filterActionableQueryRecords,
+  filterActionableSkillUsageRecords,
+} from "./utils/query-filter.js";
+import { readEffectiveSkillUsageRecords } from "./utils/skill-log.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -36,6 +41,8 @@ export function computeLastInsight(
   queryRecords: QueryLogRecord[],
 ): LastSessionInsight | null {
   if (telemetry.length === 0) return null;
+  const actionableSkillRecords = filterActionableSkillUsageRecords(skillRecords);
+  const actionableQueryRecords = filterActionableQueryRecords(queryRecords);
 
   // Find most recent telemetry record
   const sorted = [...telemetry].sort(
@@ -48,17 +55,19 @@ export function computeLastInsight(
   const triggeredSkillQueries = new Set<string>();
   const skillsTriggered = [
     ...new Set(
-      skillRecords
+      actionableSkillRecords
         .filter((r) => r.session_id === sessionId && r.triggered)
         .map((r) => {
-          triggeredSkillQueries.add(r.query.toLowerCase().trim());
+          if (typeof r.query === "string") {
+            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 sessionQueries = actionableQueryRecords.filter((r) => r.session_id === sessionId);
   const unmatchedQueries = sessionQueries
     .filter((q) => !triggeredSkillQueries.has(q.query.toLowerCase().trim()))
     .map((q) => q.query);
@@ -124,7 +133,7 @@ export function formatInsight(insight: LastSessionInsight): string {
 /** CLI main: reads logs, prints insight. */
 export function cliMain(): void {
   const telemetry = readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG);
-  const skillRecords = readJsonl<SkillUsageRecord>(SKILL_LOG);
+  const skillRecords = readEffectiveSkillUsageRecords();
   const queryRecords = readJsonl<QueryLogRecord>(QUERY_LOG);
 
   const insight = computeLastInsight(telemetry, skillRecords, queryRecords);