@jaybeeuu/agent-cortex 2.8.0 → 2.9.0

package/extensions/interrupt-bookmark/index.ts

@@ -0,0 +1,354 @@
+/**
+ * Interrupt bookmark extension.
+ *
+ * An interruption mid-task — a meeting note, PR feedback to pass on, a Slack
+ * todo — drags its turns into the context that the original task then has to
+ * carry. PI can rewind a session tree and summarise the abandoned branch, but
+ * nothing exposes that as a deliberate operation. This extension adds two tools:
+ *
+ *   - `interrupt_checkpoint` captures the current leaf id and returns it, so the
+ *     caller holds a resume point;
+ *   - `interrupt_resume` rewinds to that id, keeps the abandoned branch under a
+ *     summary, and labels the summary entry `interrupt`.
+ *
+ * The summary comes from pi's own tree-navigation summariser
+ * (`navigateTree(..., { summarize: true })`). This extension makes no model call
+ * of its own. Nothing is deleted: the abandoned branch stays in the session
+ * file, reachable from the session tree.
+ *
+ * ## Why the rewind runs in two steps
+ *
+ * PI exposes `waitForIdle()` and `navigateTree()` on `ExtensionCommandContext`
+ * only, because they can deadlock when called from a handler that runs inside a
+ * turn (`docs/extensions.md`, "ExtensionCommandContext"). A tool receives
+ * `ExtensionToolContext`, and the session throws on navigation while it is
+ * streaming — which it always is while a tool call is running. A tool therefore
+ * cannot navigate the tree, and waiting for idle inside a tool call could never
+ * finish.
+ *
+ * So the resume tool validates the request, records it, and ends the turn. An
+ * `agent_settled` handler then dispatches the command that performs the rewind,
+ * which is the pattern pi documents for a tool that must reach a command-only
+ * API (`docs/extensions.md`, "ctx.reload()"). One consequence is worth stating:
+ * the summary entry is reported to the human and written to the session as a
+ * custom entry, not returned in the tool result — the tool result belongs to the
+ * branch that the rewind summarises.
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionToolContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+/** The tool that captures a resume point. */
+export const CHECKPOINT_TOOL = "interrupt_checkpoint";
+
+/** The tool that asks for a rewind. */
+export const RESUME_TOOL = "interrupt_resume";
+
+/** The command that performs the rewind, dispatched once the turn settles. */
+export const REWIND_COMMAND = "interrupt-rewind";
+
+/** The label pi attaches to the branch-summary entry a rewind leaves behind. */
+export const SUMMARY_LABEL = "interrupt";
+
+/** Custom-entry type recording the outcome. Never part of the model's context. */
+export const REWIND_ENTRY = "interrupt-rewind";
+
+/**
+ * How many times a rewind is attempted: the first try, then exactly one retry.
+ * A second failure is reported, never retried again.
+ */
+export const REWIND_ATTEMPTS = 2;
+
+/** A rewind waiting for the turn to settle. */
+export interface RewindRequest {
+  /** The entry id the caller wants to return to. */
+  checkpointId: string;
+  /** What the interruption was about, as summariser instructions. */
+  summary: string;
+}
+
+/** What a rewind did, or why it did nothing. */
+export interface RewindReport {
+  ok: boolean;
+  /** How many navigation attempts were made. */
+  attempts: number;
+  /** The `branch_summary` entry the rewind left behind, when there is one. */
+  summaryEntryId?: string;
+  /** True when pi cancelled the navigation (an extension or the user declined). */
+  cancelled?: boolean;
+  /** Why the last attempt failed. */
+  reason?: string;
+}
+
+/** The parts of the command context a rewind uses. */
+type RewindContext = Pick<
+  ExtensionCommandContext,
+  "waitForIdle" | "navigateTree" | "sessionManager"
+>;
+
+/** The parts of the tool context the two tools read. */
+type BookmarkContext = Pick<ExtensionToolContext, "sessionManager">;
+
+/** Instructions for pi's summariser: what the interruption was, and why it is summarised. */
+export function summariserInstructions(summary: string): string {
+  return [
+    "The task was interrupted. Record what the interruption was about, and what the abandoned turns",
+    "were doing, so the task can resume without them.",
+    `The interruption: ${summary}`,
+  ].join(" ");
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * The branch-summary entry a navigation from `previousLeaf` appended, if any.
+ *
+ * `navigateTree()` returns this entry, but `ExtensionCommandContext` declares
+ * only `cancelled` in its result type, and after the call the leaf is the label
+ * entry pi appends on top of the summary. The entry is therefore found by the
+ * `fromId` pi records on it — no cast, and no assumption about the leaf.
+ */
+function summaryAfter(
+  sessionManager: RewindContext["sessionManager"],
+  previousLeaf: string | null,
+): string | undefined {
+  const entries = sessionManager.getEntries();
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry.type === "branch_summary" && entry.fromId === previousLeaf) return entry.id;
+  }
+  return undefined;
+}
+
+/**
+ * Rewind to `checkpointId`, summarising the abandoned branch.
+ *
+ * Navigation rejects while a response, a compaction or another navigation is
+ * active, so each attempt waits for idle first. Waits and attempts are
+ * deliberately paired: an attempt that skips the wait fails for the reason the
+ * wait exists.
+ */
+export async function rewind(ctx: RewindContext, request: RewindRequest): Promise<RewindReport> {
+  let reason = "";
+
+  for (let attempt = 1; attempt <= REWIND_ATTEMPTS; attempt += 1) {
+    await ctx.waitForIdle();
+
+    // Captured before the navigation, so the summary it writes can be found by
+    // the branch it abandoned.
+    const previousLeaf = ctx.sessionManager.getLeafId();
+
+    try {
+      const result = await ctx.navigateTree(request.checkpointId, {
+        summarize: true,
+        customInstructions: summariserInstructions(request.summary),
+        label: SUMMARY_LABEL,
+      });
+
+      return {
+        ok: true,
+        attempts: attempt,
+        cancelled: result.cancelled,
+        summaryEntryId: summaryAfter(ctx.sessionManager, previousLeaf),
+      };
+    } catch (error) {
+      reason = errorMessage(error);
+    }
+  }
+
+  return { ok: false, attempts: REWIND_ATTEMPTS, reason };
+}
+
+/**
+ * Why this request cannot be rewound, or undefined when it can.
+ *
+ * An unknown id is refused here, before anything is queued or written, so the
+ * session is untouched and the message names the id that failed.
+ */
+export function refusal(ctx: BookmarkContext, request: RewindRequest): string | undefined {
+  if (ctx.sessionManager.getEntry(request.checkpointId) === undefined) {
+    return `Unknown checkpoint id: ${request.checkpointId}. Call ${CHECKPOINT_TOOL} to record a resume point.`;
+  }
+
+  if (ctx.sessionManager.getLeafId() === request.checkpointId) {
+    return `Checkpoint ${request.checkpointId} is the current position, so there are no interrupt turns to summarise. Nothing was rewound.`;
+  }
+
+  return undefined;
+}
+
+export default function interruptBookmarkExtension(pi: ExtensionAPI): void {
+  /**
+   * The rewind the next settle must dispatch. At most one: a second would
+   * navigate from a position the first has already replaced.
+   */
+  let pending: RewindRequest | undefined;
+
+  /**
+   * The summary waiting for its dispatch, keyed by checkpoint id. The command
+   * receives the id in its argument text and the summary from here, so a summary
+   * with spaces or newlines never has to survive a command line. One entry at a
+   * time: a new request replaces the previous one.
+   */
+  const handoff = new Map<string, string>();
+
+  pi.registerTool({
+    name: CHECKPOINT_TOOL,
+    label: "Interrupt Checkpoint",
+    description:
+      "Record the current session position and return its id, so an interruption can be rewound later.",
+    promptSnippet: `${CHECKPOINT_TOOL}: record a resume point before handling an interruption`,
+    promptGuidelines: [
+      `Use ${CHECKPOINT_TOOL} before an interruption is handled, and ${RESUME_TOOL} to return to it afterwards.`,
+    ],
+    parameters: Type.Object({}),
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      const leafId = ctx.sessionManager.getLeafId();
+
+      if (leafId === null) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "The session has no entries yet, so there is no position to record.",
+            },
+          ],
+          details: { checkpointId: null },
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Checkpoint ${leafId}. Pass this id to ${RESUME_TOOL} to rewind here.`,
+          },
+        ],
+        details: { checkpointId: leafId },
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: RESUME_TOOL,
+    label: "Interrupt Resume",
+    description:
+      "Rewind to a checkpoint, keep the abandoned branch under a summary, then continue from the checkpoint. Runs after the current turn ends.",
+    promptSnippet: `${RESUME_TOOL}: rewind to a checkpoint and summarise the interruption away`,
+    parameters: Type.Object({
+      checkpointId: Type.String({
+        description: `The id ${CHECKPOINT_TOOL} returned.`,
+      }),
+      summary: Type.String({
+        description: "What the interruption was about, so the summariser records it.",
+      }),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      if (pending !== undefined) {
+        throw new Error(
+          `A rewind to ${pending.checkpointId} is already scheduled. Nothing was changed.`,
+        );
+      }
+
+      const problem = refusal(ctx, params);
+      if (problem !== undefined) {
+        // A thrown message reaches the model as the tool's error result, and
+        // nothing has been written or queued at this point.
+        throw new Error(problem);
+      }
+
+      pending = { checkpointId: params.checkpointId, summary: params.summary };
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text:
+              `Rewind to ${params.checkpointId} scheduled. The abandoned branch is kept under a ` +
+              `summary labelled "${SUMMARY_LABEL}" once this turn ends; this tool call is part of it.`,
+          },
+        ],
+        details: { checkpointId: params.checkpointId, scheduled: true },
+        // The rewind needs the turn over, so end it rather than letting the model
+        // keep working in a context that is about to be rewound.
+        terminate: true,
+      };
+    },
+  });
+
+  // Command handlers are the only place pi allows tree navigation. The dispatch
+  // uses `expandPromptTemplates`, which runs the command instead of prompting the
+  // model, so nothing is sent to a provider here.
+  pi.registerCommand(REWIND_COMMAND, {
+    description: "Rewind to a scheduled interrupt checkpoint and summarise the abandoned branch",
+    handler: async (args, ctx) => {
+      const checkpointId = args.trim();
+
+      if (checkpointId === "") {
+        ctx.ui.notify("No checkpoint was named, so nothing was rewound.", "warning");
+        return;
+      }
+
+      const summary = handoff.get(checkpointId);
+      if (summary === undefined) {
+        ctx.ui.notify(
+          `No interrupt rewind is pending for ${checkpointId}, so nothing was rewound.`,
+          "warning",
+        );
+        return;
+      }
+      handoff.delete(checkpointId);
+
+      const report = await rewind(ctx, { checkpointId, summary });
+      pi.appendEntry(REWIND_ENTRY, {
+        checkpointId,
+        attempts: report.attempts,
+        ok: report.ok,
+        cancelled: report.cancelled ?? false,
+        summaryEntryId: report.summaryEntryId,
+        reason: report.reason,
+      });
+
+      if (!report.ok) {
+        ctx.ui.notify(
+          `Interrupt rewind to ${checkpointId} failed after ${report.attempts} attempts: ${report.reason}. The conversation is unchanged; continue in the current context and say the rewind failed.`,
+          "error",
+        );
+        return;
+      }
+
+      if (report.cancelled === true) {
+        ctx.ui.notify(
+          `Interrupt rewind to ${checkpointId} was cancelled. The conversation is unchanged.`,
+          "warning",
+        );
+        return;
+      }
+
+      const summaryEntry =
+        report.summaryEntryId === undefined ? "" : ` (summary entry ${report.summaryEntryId})`;
+      ctx.ui.notify(
+        `Rewound to ${checkpointId}${summaryEntry}. The abandoned branch is kept, labelled "${SUMMARY_LABEL}".`,
+        "info",
+      );
+    },
+  });
+
+  pi.on("agent_settled", () => {
+    const request = pending;
+    if (request === undefined) return;
+
+    // Taken here, so a second settle cannot dispatch the same rewind twice. A
+    // dispatch that never runs leaves no pending request behind.
+    pending = undefined;
+    handoff.clear();
+    handoff.set(request.checkpointId, request.summary);
+    pi.sendUserMessage(`/${REWIND_COMMAND} ${request.checkpointId}`, { expandPromptTemplates: true });
+  });
+}

package/extensions/interrupt-bookmark/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@agent-cortex/interrupt-bookmark",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test --import tsx/esm index.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^1.5.2",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typebox": "^1.1.38",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "typebox": "*"
+  }
+}

package/extensions/skill-stats/README.md

@@ -16,7 +16,63 @@ A skill that is *loaded* frequently but *never read* may be burning context budg
 
 ## Data
 
-Usage data is stored in `~/.pi/agent-cortex/skill-usage.json` — a single file across all projects, with per-project breakdowns so you can slice by project.
+Usage data is stored in `~/.pi/agent-cortex/` — global, across all projects, with per-project
+breakdowns so you can slice by project. There are two files, with different fidelity:
+
+| File | Fidelity | Kept for |
+|---|---|---|
+| `skill-usage.json` | Per-skill counters, per-project breakdown, and a 200-event ring of recent events | Until a skill has been unused for ~3 months (existing age-out) |
+| `skill-usage-daily.json` | One record per skill per day: loaded / invoked / read counts and the distinct projects seen that day | 365 days by default, pruned on every write |
+
+The counters answer "what is my all-time shape, and what happened in the last few minutes". The
+daily rollups answer "how has my usage changed over months" without scanning session transcripts.
+The rollups are a second file beside the counters, not a replacement: the counters and their
+200-event ring are unchanged by this feature.
+
+### Retention and size policy
+
+- **Retention window: 365 days by default.** Override it per machine with
+  `AGENT_CORTEX_SKILL_STATS_RETENTION_DAYS` (a positive whole number of days). Invalid values fall
+  back to the default.
+- **Pruning happens on write, not on read.** Every save drops day records older than the window, so a
+  long-lived install can never accumulate more than the window's worth of days. The `timeline` view
+  only reads; it prunes nothing.
+- **Each record is fixed-size.** Counts are numbers, the distinct-project list per skill-day is capped
+  at 50 entries, and a stored project path is truncated to 120 characters, so one skill-day's record
+  cannot grow with the number of events that day or with working-directory depth. Two long paths that
+  share their first 120 characters count as one project.
+- **The file has a hard ceiling of 2,920,000 bytes, enforced on every write.** That is 365 days x 40
+  skills x 200 bytes per skill-day (the counts plus one realistic project path); the 40 sizes the
+  budget and is not a limit on how many skills an install may have. A realistic file is far smaller:
+  994,668 bytes for 40 skills used every day of the window, two events each and a short project path
+  (`/proj/a`), and 1,272,068 bytes for the same usage with a 26-character project path. A retention
+  window longer than 365 days does not raise the ceiling, so the detail it implies is shed by the
+  rule below.
+  When a write would exceed the ceiling, `saveRollups` drops the per-skill-day project lists first —
+  the loaded / invoked / read counts and every day survive, and every number the timeline renders is
+  unchanged. Only if the counts alone exceed the ceiling does it drop the oldest days, continuing the
+  direction pruning already takes. `saveRollups` returns what this write gave up
+  (`shedProjectLists`, `droppedDays`) and the size it wrote, and it keeps running totals in the file
+  under `shed`, so `/skill-stats timeline` reports the loss after a reload rather than leaving the
+  user to find out only by looking. The rendered line names the day of the most recent shedding
+  write, how many project lists and how many days went in total, and the ceiling that forced it.
+- **A ceiling shed moves the reported start; ordinary pruning does not.** When shedding drops whole
+  days, those days were inside the retention window, so `since` moves to the oldest day the file
+  still holds and the header can never claim a day that was deleted. Days that age out of the window
+  are different: they were real history and the rendered retention line explains them, so `since`
+  keeps the first-ever day.
+- **The file is written minified** — it is read by the extension, not by a human. The suite fills
+  every cap at once (40 skills x 365 days x 50 project paths), asserts the 22,033,268 raw bytes are
+  written as at most 2,920,000, and asserts a second year of data leaves the file byte-for-byte
+  unchanged.
+
+### History before the rollups
+
+Rollups start with the first skill event recorded after this version was installed. Anything earlier
+is reported as **unavailable**, not as zero usage, and no data point is invented for it. A ceiling
+shed that deletes days reports on the same screen, so a moved start is explained rather than silent.
+Backfilling from old session transcripts is a possible follow-up, and deliberately not part of this
+feature.
 
 ## Installation
 
@@ -43,7 +99,8 @@ ln -sf $(pwd)/extensions/skill-stats ~/.pi/agent/extensions/skill-stats
 |---|---|
 | `/skill-stats` | Show usage dashboard with per-project slicing |
 | `/skill-stats --project ./relative/path` | Filter to a specific project |
-| `/skill-usage-reset` | Wipe all recorded data |
+| `/skill-stats timeline` | Per-day, per-week and per-month counts and distinct skills, from the daily rollups |
+| `/skill-usage-reset` | Wipe all recorded data, counters and rollups |
 
 ## Raw data
 
@@ -59,7 +116,7 @@ The JSON file at `~/.pi/agent-cortex/skill-usage.json` contains the full record:
       "readCount": 18,
       "lastUsed": "2026-06-07T...",
       "byProject": {
-        "/home/jaybeeuu/src/agent-cortex": {
+        "/home/user/projects/app": {
           "loadedCount": 40,
           "invokedCount": 3,
           "readCount": 16,
@@ -72,3 +129,27 @@ The JSON file at `~/.pi/agent-cortex/skill-usage.json` contains the full record:
   "lastUpdated": "2026-06-07T..."
 }
 ```
+
+The rollups in `~/.pi/agent-cortex/skill-usage-daily.json` are minified and keyed by day:
+
+```json
+{
+  "version": 1,
+  "since": "2026-06-01",
+  "days": {
+    "2026-06-07": {
+      "bd-tool": { "loaded": 2, "invoked": 1, "read": 3, "projects": ["/home/user/projects/app"] }
+    }
+  },
+  "shed": { "on": "2026-06-08", "projectLists": 14600, "days": 0 }
+}
+```
+
+`since` is the first day a rollup is held for. It survives pruning, so the timeline can say where
+the recorded history starts; it moves forward only when a ceiling shed deletes days, which nothing
+else explains.
+
+`shed` appears only after a write had to give up detail for the size ceiling, and holds the totals
+dropped by shedding (`projectLists`, `days`) plus the day of the most recent such write. A file
+written before this field existed has no `shed` key, and such a file loads and renders unchanged:
+an absent record means nothing was shed.

package/extensions/skill-stats/index.ts

@@ -4,13 +4,56 @@ import path from "node:path";
 // Re-export public API for tests and consumers
 export { type ProjectCounts, type SkillStats, type UsageStore, type RawEvent, loadStore, saveStore, ageOutStore } from "./store.js";
 export { recordUsage } from "./record.js";
+export {
+  type DaySkillCounts,
+  type Granularity,
+  type RollupStore,
+  type SaveRollupsResult,
+  type ShedRecord,
+  type TimelineBucket,
+  DEFAULT_RETENTION_DAYS,
+  MAX_PROJECT_PATH_CHARS,
+  MAX_PROJECTS_PER_DAY,
+  MAX_ROLLUP_FILE_BYTES,
+  RETENTION_ENV,
+  bucketKey,
+  dayKey,
+  loadRollups,
+  oldestDay,
+  pruneRollups,
+  recordDailyUsage,
+  retentionCutoff,
+  retentionDays,
+  rollupFilePath,
+  saveRollups,
+  shiftDay,
+  timeline,
+} from "./rollup.js";
+export { formatTimeline, isTimelineRequest } from "./timeline.js";
 export { type SkillRecord, globalSkillDirs, scanSkills, extractSkillName, discoverProjectSkills, resolveSkillFromPath } from "./discover.js";
 export { formatTable } from "./format.js";
 
-import { loadStore, saveStore } from "./store.js";
+import { loadStore, saveStore, type RawEvent } from "./store.js";
 import { recordUsage } from "./record.js";
 import { resolveSkillFromPath, globalSkillDirs, scanSkills, discoverProjectSkills } from "./discover.js";
 import { formatTable } from "./format.js";
+import { loadRollups, recordDailyUsage, saveRollups } from "./rollup.js";
+import { formatTimeline, isTimelineRequest } from "./timeline.js";
+
+/**
+ * Record one usage event into the long-range rollups. The counters and the
+ * recent-event ring in the store are written by `recordUsage`/`saveStore` as
+ * before; this adds the per-day record beside them.
+ */
+function recordRollup(
+  skillName: string,
+  source: RawEvent["source"],
+  project: string,
+): void {
+  const rollups = loadRollups();
+  recordDailyUsage(rollups, skillName, source, project);
+  saveRollups(rollups);
+}
 
 // ── Extension entry point ─────────────────────────────────────────────────────
 
@@ -32,12 +75,16 @@ export default function (pi: ExtensionAPI) {
     if (!skills?.length) return;
 
     const store = loadStore();
+    const rollups = loadRollups();
     const project = ctx.cwd;
     for (const skill of skills) {
       const name = typeof skill === "string" ? skill : skill.name;
-      if (name) recordUsage(store, name, "loaded", project);
+      if (!name) continue;
+      recordUsage(store, name, "loaded", project);
+      recordDailyUsage(rollups, name, "loaded", project);
     }
     saveStore(store);
+    saveRollups(rollups);
   });
 
   // ── 2. Track /skill:name invocations ──────────────────────────────────
@@ -48,6 +95,7 @@ export default function (pi: ExtensionAPI) {
     const store = loadStore();
     recordUsage(store, m[1], "invoked", ctx.cwd);
     saveStore(store);
+    recordRollup(m[1], "invoked", ctx.cwd);
   });
 
   // ── 3. Track SKILL.md reads by the LLM ────────────────────────────────
@@ -64,6 +112,7 @@ export default function (pi: ExtensionAPI) {
     const store = loadStore();
     recordUsage(store, skillName, "read", ctx.cwd);
     saveStore(store);
+    recordRollup(skillName, "read", ctx.cwd);
   });
 
   // ── 4. Track turns ────────────────────────────────────────────────────
@@ -88,8 +137,17 @@ export default function (pi: ExtensionAPI) {
   // ── 5. /skill-stats command ───────────────────────────────────────────
   pi.registerCommand("skill-stats", {
     description:
-      "Show skill usage stats. Filter by project: /skill-stats --project <path>",
+      "Show skill usage stats. Filter by project: /skill-stats --project <path>. Long-range history: /skill-stats timeline",
     handler: async (args, ctx) => {
+      // The timeline view reads the daily rollups and nothing else — not the
+      // counters, and never a session transcript.
+      if (isTimelineRequest(args)) {
+        const output = formatTimeline(loadRollups());
+        ctx.ui.notify("Skill usage timeline from daily rollups.", "info");
+        console.log(output);
+        return;
+      }
+
       const store = loadStore();
 
       let projectFilter: string | null = null;
@@ -216,6 +274,7 @@ export default function (pi: ExtensionAPI) {
         lastUpdated: new Date().toISOString(),
         recentEvents: [],
       });
+      saveRollups({ version: 1, since: null, days: {} });
       ctx.ui.notify("Skill usage statistics reset.", "info");
     },
   });

package/extensions/skill-stats/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "test": "node --test --import tsx/esm index.test.ts",
+    "test": "node --test --import tsx/esm index.test.ts rollup.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {