opencode-skill-audit 0.1.1 → 0.2.0-dev.pr3.36976113060

package/README.md

@@ -12,22 +12,29 @@ Deterministic audit trail for [Claude Code](https://code.claude.com),
 observable **skills** were invoked, when, and which **files** were changed afterwards. It gives you
 a quick skill-compliance signal before you read the code.
 
-On opencode it also renders live in the TUI sidebar, so the audit sits next to the conversation
-with no command to run.
+On opencode it also renders live in the TUI sidebar, and on Claude Code in a live pane, so the audit
+sits next to the conversation 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,12 +76,22 @@ 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
 opencode ──tool.execute.after──▶ plugin ────┘             │
                                                           ├─▶ skill-audit status/report/watch/list
-                                                          └─▶ opencode sidebar (live)
+                                                          ├─▶ opencode sidebar (live)
+                                                          └─▶ Claude Code pane (live)
 ```
 
 The log is the only contract between the writers and the viewers, so the CLI reads opencode
@@ -93,6 +110,22 @@ Subagent hook calls use the parent session ID, so delegated edits appear in the
 
 Restart Claude Code so the hooks load.
 
+#### Live pane
+
+The plugin also opens a **Skill audit** pane showing the current session's timeline. It refreshes
+after every skill and file-edit tool call, and polls the log every two seconds.
+
+- **Opening:** it opens by itself at session start once the terminal is 144 columns or wider.
+  Narrower terminals hold it back until you run `/skill-audit-pane`, which opens it at any width.
+- **Placement:** in fullscreen from 110 columns it docks beside the transcript and shows the full
+  timeline. Press a `▼`/`▶` marker to collapse or expand a run or an hour. Elsewhere it sits above
+  the prompt in a compact form: the header and the latest run.
+- **Other panes:** panes from other plugins become tabs beside it (click a tab, or ctrl+x tab).
+  Only one is shown at a time. Esc or the close mark closes it.
+
+The pane is display only. The shell hooks keep writing the log through `logger.sh`, so recording
+works the same on Claude Code builds without plugin function hooks.
+
 > **Migrating from a manual setup?** Remove any `logger.sh` entries from the `hooks` block of
 > `~/.claude/settings.json` first, or every event is logged twice.
 
@@ -218,6 +251,7 @@ If `list` prints `no session logs in ...`, nothing was written. Go to
 | `skill-audit --help`       | Usage summary                                                    |          0 |
 | `! skill-audit status`     | Run inside a Claude Code session. Queues while the model is busy |          0 |
 | opencode sidebar           | Live timeline beside the conversation. No command to run         |          0 |
+| Claude Code pane           | Live timeline in a pane. `/skill-audit-pane` opens it            |          0 |
 | `/skill-audit`             | Show the report inside Claude Code                               | Model turn |
 | `$skill-audit`             | Show the report inside Codex                                     | Model turn |
 
@@ -345,6 +379,8 @@ and sidebar are TypeScript (`src/`) built with [Bun](https://bun.sh).
 |-------------------|----------------------------------------------------------------------------|
 | `scripts/`        | `logger.sh` hook target, the `skill-audit` CLI, `sync-versions.mjs`        |
 | `src/`            | opencode plugin (`index.ts`), sidebar (`tui.ts`), shared log and view code |
+| `hooks/`          | Claude Code shell hooks (`hooks.json`) and the live pane (`claude.tsx`)    |
+| `types/`          | `$.state` contract for the Claude Code pane                                |
 | `test/`           | Bun tests, fixtures, and `test/format-contract.sh`                         |
 | `.claude-plugin/` | Claude Code plugin manifest and marketplace entry                          |
 | `.codex-plugin/`  | Codex plugin manifest                                                      |
@@ -359,17 +395,28 @@ bun run check     # format:check + lint + typecheck (src and test) + tests
 bun run build     # dist/index.js (plugin) and dist/tui.js (sidebar)
 ```
 
-| Script                   | What                                                     |
-|--------------------------|----------------------------------------------------------|
-| `bun run format`         | Prettier, write mode                                     |
-| `bun run lint`           | ESLint over `src` and `test`                             |
-| `bun run typecheck`      | `tsc --noEmit` for `src`                                 |
-| `bun test`               | Bun test suite in `test/`                                |
-| `bun run check`          | Everything CI runs                                       |
-| `bun run check:versions` | Assert `package.json` and both `plugin.json` files agree |
-| `bun run sync:versions`  | Rewrite the plugin manifests from `package.json`         |
-
-Tests live in `test/`. `test/format-contract.sh` pins the rendered CLI output against fixtures, so
+| Script                     | What                                                     |
+|----------------------------|----------------------------------------------------------|
+| `bun run format`           | Prettier, write mode                                     |
+| `bun run lint`             | ESLint over `src` and `test`                             |
+| `bun run typecheck`        | `tsc --noEmit` for `src`                                 |
+| `bun test`                 | Bun test suite in `test/`                                |
+| `bun run check`            | Everything CI runs                                       |
+| `bun run test:claude`      | Validate and test the Claude Code pane (needs `claude`)  |
+| `bun run typecheck:claude` | Type-check the pane (needs `.claude-plugin/types/`)      |
+| `bun run check:versions`   | Assert `package.json` and both `plugin.json` files agree |
+| `bun run sync:versions`    | Rewrite the plugin manifests from `package.json`         |
+
+Tests live in `test/`. The Claude Code pane is the exception: its tests (`hooks/*.test.tsx`) run
+in Claude Code's mod sandbox, which has no Node or Bun, so `bun test` is rooted at `test/`
+(`bunfig.toml`). `test:claude` copies the pane's files into a scratch folder and runs
+`claude plugin validate` and `claude plugin test` there. `src/core.ts` and `src/view.ts` must stay
+free of `node:*` imports and `process` because the pane imports them; `test/core.test.ts` checks
+this. `typecheck:claude` reads the API types the engine writes to `.claude-plugin/types/` once it
+has loaded the plugin from a local folder. That folder is gitignored and not available in CI, so
+neither pane check runs in CI.
+
+`test/format-contract.sh` pins the rendered CLI output against fixtures, so
 a change to the timeline format has to be updated there deliberately. That output is the contract
 the sidebar and any third-party viewer rely on.
 

package/dist/core.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The log model with no Node dependency. The Claude Code pane runs in a
+ * sandbox without `node:*` modules or `process`, so everything it shares with
+ * the CLI and the opencode sidebar lives here; `log.ts` adds the file I/O.
+ */
+export type SkillEvent = {
+    ts: string;
+    kind: "skill";
+    name: string;
+    args?: string;
+    cwd?: string;
+    source?: string;
+};
+export type FileEvent = {
+    ts: string;
+    kind: "file";
+    tool: string;
+    path: string;
+    cwd?: string;
+};
+export type AuditEvent = SkillEvent | FileEvent;
+/**
+ * An environment variable where the host has one, `undefined` where it does
+ * not. Read through `globalThis` because a bare `process` throws in the Claude
+ * Code sandbox.
+ */
+export declare function env(name: string): string | undefined;
+/**
+ * Parse NDJSON log text. Malformed lines are dropped rather than thrown on: the
+ * sidebar reads the log while the logger is appending to it, so a truncated
+ * trailing line is expected, not exceptional.
+ */
+export declare function parse(text: string): AuditEvent[];
+export declare const NO_SKILL = "(no skill active)";
+export type TimelineFile = {
+    ts: string;
+    tool: string;
+    path: string;
+};
+export type SkillRun = {
+    skill: string;
+    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;
+/** `SKILL_AUDIT_IDLE_MINUTES` as milliseconds, or the default when unusable. */
+export declare function idleGapFrom(minutes: string | undefined): 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[], gapMs?: number): SkillRun[];
+export type Summary = {
+    runs: number;
+    distinct: number;
+    files: number;
+    orphan: number;
+};
+export declare function summarize(events: AuditEvent[], gapMs?: number): Summary;
+export type SessionView = {
+    runs: SkillRun[];
+    summary: Summary;
+    cwd: string;
+};
+/** A session's view from its raw log text; empty text is an empty session. */
+export declare function toView(text: string, gapMs?: number): SessionView;
+/** `node:path` basename for POSIX paths: the last segment, trailing slashes ignored. */
+export declare function baseName(path: string): string;
+/**
+ * `path` relative to `cwd` when it sits under it, else `path` as given. The
+ * sidebar only ever shortens paths inside the session directory.
+ */
+export declare function relativeTo(path: string, cwd: string): string;

package/dist/index.js

@@ -3,6 +3,11 @@
 import { appendFileSync, mkdirSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { isAbsolute, join } from "path";
+
+// src/core.ts
+var DEFAULT_IDLE_GAP_MS = 30 * 60000;
+
+// src/log.ts
 function logDir() {
   return process.env.SKILL_AUDIT_DIR || join(homedir(), ".claude", "skill-audit");
 }

package/dist/log.d.ts

@@ -1,51 +1,8 @@
+import { type SessionView } from "./core";
+export * from "./core";
 /** Directory holding the per-session NDJSON logs, shared with the bash logger. */
 export declare function logDir(): string;
 export declare function logPath(sessionID: string): string;
-export type SkillEvent = {
-    ts: string;
-    kind: "skill";
-    name: string;
-    args?: string;
-    cwd?: string;
-    source?: string;
-};
-export type FileEvent = {
-    ts: string;
-    kind: "file";
-    tool: string;
-    path: string;
-    cwd?: string;
-};
-export type AuditEvent = SkillEvent | FileEvent;
-/**
- * Parse NDJSON log text. Malformed lines are dropped rather than thrown on: the
- * sidebar reads the log while the logger is appending to it, so a truncated
- * trailing line is expected, not exceptional.
- */
-export declare function parse(text: string): AuditEvent[];
-export declare const NO_SKILL = "(no skill active)";
-export type TimelineFile = {
-    ts: string;
-    tool: string;
-    path: string;
-};
-export type SkillRun = {
-    skill: string;
-    ts: string;
-    files: TimelineFile[];
-};
-/**
- * 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.
- */
-export declare function group(events: AuditEvent[]): SkillRun[];
-export type Summary = {
-    runs: number;
-    distinct: number;
-    files: number;
-    orphan: number;
-};
-export declare function summarize(events: AuditEvent[]): Summary;
 export declare function appendSkill(sessionID: string, input: {
     ts: string;
     name: string;
@@ -65,11 +22,6 @@ export declare function appendFile(sessionID: string, input: {
 export declare function parsePatch(args: unknown): string[];
 /** Second-precision UTC timestamp, matching `date -u +%FT%TZ` in logger.sh. */
 export declare function nowTs(date?: Date): string;
-export type SessionView = {
-    runs: SkillRun[];
-    summary: Summary;
-    cwd: string;
-};
 /**
  * Read one session's log. A missing or unreadable file is an empty session, not
  * an error: the sidebar renders before the first event is ever written.

package/dist/tui.js

@@ -7,11 +7,11 @@ import { createSignal, onCleanup } from "solid-js";
 import { appendFileSync, mkdirSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { isAbsolute, join } from "path";
-function logDir() {
-  return process.env.SKILL_AUDIT_DIR || join(homedir(), ".claude", "skill-audit");
-}
-function logPath(sessionID) {
-  return join(logDir(), `${sessionID}.ndjson`);
+
+// src/core.ts
+function env(name) {
+  const host = globalThis;
+  return host.process?.env?.[name];
 }
 function parse(text) {
   const events = [];
@@ -30,8 +30,20 @@ function parse(text) {
   return events;
 }
 var NO_SKILL = "(no skill active)";
-function group(events) {
+var DEFAULT_IDLE_GAP_MS = 30 * 60000;
+function idleGapFrom(minutes) {
+  const value = Number(minutes);
+  return Number.isFinite(value) && value > 0 ? value * 60000 : DEFAULT_IDLE_GAP_MS;
+}
+function idleGapMs() {
+  return idleGapFrom(env("SKILL_AUDIT_IDLE_MINUTES"));
+}
+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 +51,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,10 +68,11 @@ function group(events) {
       tool: event.tool,
       path: event.path
     });
+    lastActivity = epoch(event.ts);
   }
   return runs;
 }
-function summarize(events) {
+function summarize(events, gapMs = idleGapMs()) {
   const names = [];
   const paths = new Set;
   for (const event of events) {
@@ -66,7 +82,7 @@ function summarize(events) {
       paths.add(event.path);
     }
   }
-  const orphan = group(events).filter((run) => run.skill === NO_SKILL).reduce((total, run) => total + run.files.length, 0);
+  const orphan = group(events, gapMs).filter((run) => run.skill === NO_SKILL).reduce((total, run) => total + run.files.length, 0);
   return {
     runs: names.length,
     distinct: new Set(names).size,
@@ -74,73 +90,137 @@ function summarize(events) {
     orphan
   };
 }
-var EMPTY = {
-  runs: [],
-  summary: {
-    runs: 0,
-    distinct: 0,
-    files: 0,
-    orphan: 0
-  },
-  cwd: ""
-};
+function toView(text, gapMs = idleGapMs()) {
+  const events = parse(text);
+  const cwd = events.find((event) => event.cwd)?.cwd ?? "";
+  return {
+    runs: group(events, gapMs),
+    summary: summarize(events, gapMs),
+    cwd
+  };
+}
+function baseName(path) {
+  const trimmed = path.replace(/\/+$/, "");
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+function relativeTo(path, cwd) {
+  return cwd && path.startsWith(`${cwd}/`) ? path.slice(cwd.length + 1) : path;
+}
+
+// src/log.ts
+function logDir() {
+  return process.env.SKILL_AUDIT_DIR || join(homedir(), ".claude", "skill-audit");
+}
+function logPath(sessionID) {
+  return join(logDir(), `${sessionID}.ndjson`);
+}
 function readSession(sessionID) {
   let text;
   try {
     text = readFileSync(logPath(sessionID), "utf8");
   } catch {
-    return EMPTY;
+    text = "";
   }
-  const events = parse(text);
-  const cwd = events.find((event) => event.cwd)?.cwd ?? "";
-  return {
-    runs: group(events),
-    summary: summarize(events),
-    cwd
-  };
+  return toView(text);
 }
 
 // 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 iconsFor(style) {
+  return style === "emoji" ? EMOJI_ICONS : TEXT_ICONS;
+}
+function icons() {
+  return iconsFor(env("SKILL_AUDIT_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 headerLine(summary) {
-  const counts = `\u26A1${summary.runs} \u270E${summary.files}${summary.orphan > 0 ? ` \u26A0${summary.orphan}` : ""}`;
+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, 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);
+function runTitle(run, collapsed, 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, 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;
+  const rel = relativeTo(path, cwd);
   if (rel.length <= width) {
     return rel;
   }
-  const base = basename(rel);
+  const base = baseName(rel);
   if (base.length <= width) {
     return base;
   }
   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 = options.icons ?? icons();
+  const marker = options.sectionOpen ? icon.open : icon.closed;
   const lines = [
     {
-      text: `${marker} ${headerLine(view.summary)}`,
+      text: `${marker} ${headerLine(view.summary, icon)}`,
       tone: "text"
     }
   ];
@@ -155,20 +235,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, icon),
       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, icon)}`,
+        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 +347,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 +371,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,59 @@
-import { type SessionView, type SkillRun, type Summary } from "./log";
+import { type SessionView, type SkillRun, type Summary, type TimelineFile } from "./core";
+export type IconSet = {
+    run: string;
+    file: string;
+    warn: string;
+    open: string;
+    closed: string;
+};
+/** The icon set for a `SKILL_AUDIT_ICONS` value; anything but `emoji` is the text set. */
+export declare function iconsFor(style: string | undefined): IconSet;
+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;
-export declare function headerLine(summary: Summary): string;
-export declare function runTitle(run: SkillRun, collapsed: boolean): 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, icon?: IconSet): string;
+/** The skill name leads the row; its times live on the hour buckets below it. */
+export declare function runTitle(run: SkillRun, collapsed: boolean, icon?: IconSet): string;
+export declare function hourTitle(bucket: HourBucket, collapsed: boolean, icon?: IconSet): 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;
+    /** Icons to draw with; the environment's set when omitted. */
+    icons?: IconSet;
 };
+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.2.0-dev.pr3.36976113060",
   "description": "Audit trail of skill invocations and file changes, with a live timeline in the opencode sidebar",
   "type": "module",
   "license": "MIT",
@@ -40,17 +40,19 @@
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "format": "prettier --write src test package.json tsconfig.json tsconfig.test.json eslint.config.js .github/workflows/ci.yml",
-    "format:check": "prettier --check src test package.json tsconfig.json tsconfig.test.json eslint.config.js .github/workflows/ci.yml",
+    "format": "prettier --write src test hooks/claude.tsx hooks/claude.test.tsx types package.json tsconfig.json tsconfig.test.json tsconfig.claude.json eslint.config.js .github/workflows/ci.yml",
+    "format:check": "prettier --check src test hooks/claude.tsx hooks/claude.test.tsx types package.json tsconfig.json tsconfig.test.json tsconfig.claude.json eslint.config.js .github/workflows/ci.yml",
     "lint": "eslint src test",
     "build:types": "tsc --emitDeclarationOnly",
     "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",
+    "test:claude": "./test/claude-pane.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",
+    "typecheck:claude": "tsc -p tsconfig.claude.json",
+    "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",