opencode-skill-audit 0.1.1 → 0.1.2

package/README.md

@@ -16,18 +16,25 @@ On opencode it also renders live in the TUI sidebar, so the audit sits next to t
 with no command to run.
 
 ```text
-● Skill audit — f3a91c2e · ~/Dev/Web · 14:02→14:20 UTC
-
-  14:02 ⚡ superpowers:brainstorming
-  14:05 ⚡ superpowers:test-driven-development
-  14:06 │  ✎ src/auth/token.ts  Edit
-  14:09 │  ✎ src/auth/token.test.ts  Write
-  14:20 ⚠ (no skill active)
-  14:20 │  ✎ src/index.ts  Edit
-
-● 2 skill runs (2 distinct) · 3 files touched · ⚠ 1 edits outside skill context
+● Skill audit — f3a91c2e · ~/Dev/Web · 14:02→16:40
+
+  ⚡ superpowers:brainstorming
+  ⚡ superpowers:test-driven-development
+     14:00  (2)
+       14:06 ✎ src/auth/token.ts  Edit
+       14:09 ✎ src/auth/token.test.ts  Write
+     15:00  (1)
+       15:12 ✎ src/auth/session.ts  Edit
+  ⚠ (no skill active)
+     16:00  (1)
+       16:40 ✎ src/index.ts  Edit
+
+● 2 skill runs (2 distinct) · 4 files touched · ⚠ 1 edits outside skill context
 ```
 
+The skill leads each block; the hours beneath it show when its work actually happened. Times are
+your local clock — the log itself stays UTC, so a session stays readable across machines.
+
 ## Why
 
 You ask an agent to follow a skill. Did it? Reading the transcript to find out is slow, and asking
@@ -69,6 +76,15 @@ Events are appended as NDJSON to `~/.claude/skill-audit/<session_id>.ndjson`. Al
 write to that one directory on purpose, so any viewer can read any host's session. Override the
 location with `SKILL_AUDIT_DIR`.
 
+A skill run only claims the edits that keep arriving under it. Once 30 minutes pass with no
+activity the run closes, and later files are counted as `(no skill active)` rather than being
+attributed to whatever skill happened to run that morning. Tune the window with
+`SKILL_AUDIT_IDLE_MINUTES`.
+
+The opencode sidebar draws in fixed columns, so it defaults to icons that are always one terminal
+cell wide (`·` `✎` `!`); emoji such as `⚡` and `⚠` render two cells wide in most terminals and
+shift every row that carries them. Set `SKILL_AUDIT_ICONS=emoji` to use the emoji set anyway.
+
 ```text
 Claude Code / Codex ──hooks───▶ logger.sh ──┐
                                             ├─▶ ~/.claude/skill-audit/<sid>.ndjson

package/dist/index.js

@@ -9,6 +9,7 @@ function logDir() {
 function logPath(sessionID) {
   return join(logDir(), `${sessionID}.ndjson`);
 }
+var DEFAULT_IDLE_GAP_MS = 30 * 60000;
 function append(sessionID, event) {
   try {
     mkdirSync(logDir(), { recursive: true });

package/dist/log.d.ts

@@ -34,11 +34,23 @@ export type SkillRun = {
     ts: string;
     files: TimelineFile[];
 };
+/** How long a skill run may sit idle before it stops claiming later edits. */
+export declare const DEFAULT_IDLE_GAP_MS: number;
+/**
+ * The idle gap, in milliseconds. Without one a single skill invoked in the
+ * morning claims every edit made for the rest of the day.
+ */
+export declare function idleGapMs(): number;
 /**
  * Group a flat event list into skill runs, each carrying the files edited after
  * it. Port of the jq reduce in scripts/skill-audit; the two must agree.
+ *
+ * A run only claims edits that keep arriving: once `gapMs` passes with no
+ * activity, later files fall into a synthetic run instead. An unparseable
+ * timestamp compares as NaN, which never exceeds the gap, so logs written
+ * before this rule existed group exactly as they did before.
  */
-export declare function group(events: AuditEvent[]): SkillRun[];
+export declare function group(events: AuditEvent[], gapMs?: number): SkillRun[];
 export type Summary = {
     runs: number;
     distinct: number;

package/dist/tui.js

@@ -30,8 +30,17 @@ function parse(text) {
   return events;
 }
 var NO_SKILL = "(no skill active)";
-function group(events) {
+var DEFAULT_IDLE_GAP_MS = 30 * 60000;
+function idleGapMs() {
+  const minutes = Number(process.env.SKILL_AUDIT_IDLE_MINUTES);
+  return Number.isFinite(minutes) && minutes > 0 ? minutes * 60000 : DEFAULT_IDLE_GAP_MS;
+}
+function epoch(ts) {
+  return new Date(ts).getTime();
+}
+function group(events, gapMs = idleGapMs()) {
   const runs = [];
+  let lastActivity = NaN;
   for (const event of events) {
     if (event.kind === "skill") {
       runs.push({
@@ -39,9 +48,12 @@ function group(events) {
         ts: event.ts,
         files: []
       });
+      lastActivity = epoch(event.ts);
       continue;
     }
-    if (runs.length === 0) {
+    const current = runs[runs.length - 1];
+    const stale = epoch(event.ts) - lastActivity > gapMs;
+    if (!current || stale && current.skill !== NO_SKILL) {
       runs.push({
         skill: NO_SKILL,
         ts: event.ts,
@@ -53,6 +65,7 @@ function group(events) {
       tool: event.tool,
       path: event.path
     });
+    lastActivity = epoch(event.ts);
   }
   return runs;
 }
@@ -102,27 +115,76 @@ function readSession(sessionID) {
 
 // src/view.ts
 import { basename, relative } from "path";
+var TEXT_ICONS = {
+  run: "\xB7",
+  file: "\u270E",
+  warn: "!",
+  open: "\u25BC",
+  closed: "\u25B6"
+};
+var EMOJI_ICONS = {
+  run: "\u26A1",
+  file: "\u270E",
+  warn: "\u26A0",
+  open: "\u25BC",
+  closed: "\u25B6"
+};
+function icons() {
+  return process.env.SKILL_AUDIT_ICONS === "emoji" ? EMOJI_ICONS : TEXT_ICONS;
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function local(ts) {
+  const date = new Date(ts);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
 function hhmm(ts) {
-  return ts.slice(11, 16);
+  const date = local(ts);
+  return date ? `${pad(date.getHours())}:${pad(date.getMinutes())}` : "";
+}
+function hourKey(ts) {
+  const date = local(ts);
+  return date ? `${pad(date.getHours())}:00` : "";
 }
 function shortName(name) {
   const parts = name.split(":");
   return parts[parts.length - 1] || name;
 }
+function bucketByHour(files) {
+  const buckets = [];
+  for (const file of files) {
+    const day = file.ts.slice(0, 10);
+    const hour = hourKey(file.ts);
+    const last = buckets[buckets.length - 1];
+    if (!last || last.day !== day || last.hour !== hour) {
+      buckets.push({
+        day,
+        hour,
+        files: []
+      });
+    }
+    buckets[buckets.length - 1].files.push(file);
+  }
+  return buckets;
+}
 function headerLine(summary) {
-  const counts = `\u26A1${summary.runs} \u270E${summary.files}${summary.orphan > 0 ? ` \u26A0${summary.orphan}` : ""}`;
+  const icon = icons();
+  const counts = `${icon.run}${summary.runs} ${icon.file}${summary.files}${summary.orphan > 0 ? ` ${icon.warn}${summary.orphan}` : ""}`;
   return `Skill audit  ${counts}`;
 }
 function runTitle(run, collapsed) {
-  const time = hhmm(run.ts);
-  if (run.skill === NO_SKILL) {
-    return `\u26A0 ${time} no skill`;
-  }
-  const name = shortName(run.skill);
+  const icon = icons();
+  const name = run.skill === NO_SKILL ? `${icon.warn} no skill` : shortName(run.skill);
   if (run.files.length === 0) {
-    return `  ${time} ${name}`;
+    return `  ${name}`;
   }
-  return collapsed ? `\u25B6 ${time} ${name} (${run.files.length})` : `\u25BC ${time} ${name}`;
+  return collapsed ? `${icon.closed} ${name} (${run.files.length})` : `${icon.open} ${name}`;
+}
+function hourTitle(bucket, collapsed) {
+  const icon = icons();
+  const marker = collapsed ? icon.closed : icon.open;
+  return `${marker} ${bucket.hour} (${bucket.files.length})`;
 }
 function displayPath(path, cwd, width) {
   const rel = cwd && path.startsWith(`${cwd}/`) ? relative(cwd, path) : path;
@@ -135,9 +197,17 @@ function displayPath(path, cwd, width) {
   }
   return `${base.slice(0, Math.max(0, width - 1))}\u2026`;
 }
-var FILE_INDENT = "     \u270E ";
+var HOUR_INDENT = "  ";
+var FILE_INDENT = "    ";
+function runKey(index) {
+  return `run:${index}`;
+}
+function hourKeyOf(index, bucket) {
+  return `${runKey(index)}/hour:${bucket.day} ${bucket.hour}`;
+}
 function sidebarLines(view, options) {
-  const marker = options.sectionOpen ? "\u25BC" : "\u25B6";
+  const icon = icons();
+  const marker = options.sectionOpen ? icon.open : icon.closed;
   const lines = [
     {
       text: `${marker} ${headerLine(view.summary)}`,
@@ -155,20 +225,35 @@ function sidebarLines(view, options) {
     return lines;
   }
   view.runs.forEach((run, index) => {
-    const collapsed = options.collapsed.has(index);
+    const key = runKey(index);
+    const runCollapsed = options.collapsed.has(key);
     lines.push({
-      text: runTitle(run, collapsed),
+      text: runTitle(run, runCollapsed),
       tone: run.skill === NO_SKILL ? "warning" : "accent",
-      runIndex: index
+      key
     });
-    if (collapsed) {
+    if (runCollapsed) {
       return;
     }
-    for (const file of run.files) {
+    for (const bucket of bucketByHour(run.files)) {
+      const bucketKey = hourKeyOf(index, bucket);
+      const hourCollapsed = options.collapsed.has(bucketKey);
       lines.push({
-        text: `${FILE_INDENT}${displayPath(file.path, view.cwd, options.width - FILE_INDENT.length)}`,
-        tone: "muted"
+        text: `${HOUR_INDENT}${hourTitle(bucket, hourCollapsed)}`,
+        tone: "text",
+        key: bucketKey
       });
+      if (hourCollapsed) {
+        continue;
+      }
+      for (const file of bucket.files) {
+        const stamp = `${hhmm(file.ts)} ${icon.file} `;
+        const room = options.width - FILE_INDENT.length - stamp.length;
+        lines.push({
+          text: `${FILE_INDENT}${stamp}${displayPath(file.path, view.cwd, room)}`,
+          tone: "muted"
+        });
+      }
     }
   });
   return lines;
@@ -252,10 +337,10 @@ function toneColor(theme, tone) {
   }
   return theme.text;
 }
-function toggle(set, index) {
+function toggle(set, key) {
   const next = new Set(set);
-  if (!next.delete(index)) {
-    next.add(index);
+  if (!next.delete(key)) {
+    next.add(key);
   }
   return next;
 }
@@ -276,8 +361,8 @@ function Section(api, sessionID, width) {
     const onMouseDown = index === 0 ? () => {
       setSectionOpen((open) => !open);
       redraw();
-    } : line.runIndex !== undefined ? () => {
-      setCollapsed((current) => toggle(current, line.runIndex));
+    } : line.key !== undefined ? () => {
+      setCollapsed((current) => toggle(current, line.key));
       redraw();
     } : undefined;
     return element("text", {

package/dist/view.d.ts

@@ -1,28 +1,55 @@
-import { type SessionView, type SkillRun, type Summary } from "./log";
+import { type SessionView, type SkillRun, type Summary, type TimelineFile } from "./log";
+export type IconSet = {
+    run: string;
+    file: string;
+    warn: string;
+    open: string;
+    closed: string;
+};
+export declare function icons(): IconSet;
 export declare function hhmm(ts: string): string;
+/** The local hour a timestamp belongs to, as a bucket label. */
+export declare function hourKey(ts: string): string;
 /** `superpowers:brainstorming` -> `brainstorming`, the way the statusline snippet does. */
 export declare function shortName(name: string): string;
+/** `day` is carried so a run spanning midnight gets one bucket per calendar hour. */
+export type HourBucket = {
+    day: string;
+    hour: string;
+    files: TimelineFile[];
+};
+/**
+ * Split a run's files into consecutive local-hour buckets. Consecutive rather
+ * than keyed, so the same hour on the next day opens a second bucket instead of
+ * folding a day's gap into one row.
+ */
+export declare function bucketByHour(files: TimelineFile[]): HourBucket[];
 export declare function headerLine(summary: Summary): string;
+/** The skill name leads the row; its times live on the hour buckets below it. */
 export declare function runTitle(run: SkillRun, collapsed: boolean): string;
+export declare function hourTitle(bucket: HourBucket, collapsed: boolean): string;
 /**
  * Fit a path into the sidebar: relative to the session directory, then the
  * basename, then a truncated basename.
  */
 export declare function displayPath(path: string, cwd: string, width: number): string;
 export type Tone = "text" | "muted" | "accent" | "warning";
+/** `key` marks a collapsible node; the sidebar toggles whatever key it carries. */
 export type Line = {
     text: string;
     tone: Tone;
-    runIndex?: number;
+    key?: string;
 };
 export type SidebarOptions = {
     /** Whether the whole section is expanded. */
     sectionOpen: boolean;
-    /** Indices of runs whose files are hidden. */
-    collapsed: Set<number>;
+    /** Keys of runs and hour buckets whose children are hidden. */
+    collapsed: Set<string>;
     /** Usable sidebar width, in columns. */
     width: number;
 };
+export declare function runKey(index: number): string;
+export declare function hourKeyOf(index: number, bucket: HourBucket): string;
 /**
  * The entire sidebar section as plain lines. Keeping layout here rather than in
  * the OpenTUI glue means it can be tested without a terminal.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skill-audit",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Audit trail of skill invocations and file changes, with a live timeline in the opencode sidebar",
   "type": "module",
   "license": "MIT",
@@ -47,10 +47,10 @@
     "build:index": "bun build src/index.ts --outfile dist/index.js --target bun --format esm --external @opencode-ai/plugin --external @opencode-ai/sdk",
     "build:tui": "bun build src/tui.ts --outfile dist/tui.js --target bun --format esm --external @opencode-ai/plugin --external @opencode-ai/sdk --external @opentui/core --external @opentui/solid --external solid-js",
     "build": "bun run clean && bun run build:types && bun run build:index && bun run build:tui",
-    "test": "bun test && ./test/format-contract.sh",
+    "test": "TZ=UTC bun test && TZ=UTC ./test/format-contract.sh",
     "typecheck": "tsc --noEmit",
     "typecheck:test": "tsc -p tsconfig.test.json",
-    "check": "bun run format:check && bun run lint && bun run typecheck && bun run typecheck:test && bun test && ./test/format-contract.sh",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun run typecheck:test && TZ=UTC bun test && TZ=UTC ./test/format-contract.sh",
     "check:versions": "node scripts/sync-versions.mjs --check",
     "sync:versions": "node scripts/sync-versions.mjs",
     "version": "node scripts/sync-versions.mjs && git add .claude-plugin/plugin.json .codex-plugin/plugin.json",