tarsk 0.6.87 → 0.6.88

package/dist/bundled-skills/tarsk-improve/scripts/ensure-exported.ts

@@ -0,0 +1,238 @@
+#!/usr/bin/env bun
+// @ts-nocheck — bun script outside cli/tsconfig (no Node/Bun types in staged vp check)
+/**
+ * Ensure every bundled `tarsk-*` Skill exists under the project's
+ * `.agents/skills` so Tool skill edits hit the project copy, not the
+ * read-only bundled original.
+ *
+ * `--prune` is the cleanup pass: it deletes project copies that still match
+ * bundled and creates nothing, so only `tarsk-*` Skills that actually differ
+ * stay in the repo. The host also prunes on chat load.
+ *
+ * In the Tarsk checkout the built-ins are the repo's own files, so this script
+ * copies nothing (`skipped: tarsk-checkout`) and you edit
+ * `cli/bundled-skills/tarsk-*` directly. User repos still get project copies.
+ *
+ * Usage (from the project / thread checkout root):
+ *   bun .agents/skills/tarsk-improve/scripts/ensure-exported.ts
+ *   bun <bundled>/tarsk-improve/scripts/ensure-exported.ts --project-skills .agents/skills
+ *   bun .agents/skills/tarsk-improve/scripts/ensure-exported.ts --prune
+ *
+ * Options:
+ *   --project-skills <dir>   Target .agents/skills (default: <cwd>/.agents/skills)
+ *   --bundled <dir>          Bundled-skills root (default: auto-detect)
+ *   --prune                  Delete project copies that match bundled; create nothing
+ *   --json                   Print machine-readable JSON
+ */
+
+import { existsSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  exportToolSkillsFrom,
+  isTarskCheckout,
+  listEditableToolSkills,
+  pruneUnchangedToolSkills,
+  type ExportToolSkillsResult,
+  type ToolSkillPruneResult,
+} from "./export-tool-skills-lib.js";
+
+function readFlagValue(args: string[], flag: string): string | undefined {
+  const index = args.indexOf(flag);
+  if (index === -1) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) return undefined;
+  return value;
+}
+
+function scriptDir(): string {
+  return dirname(fileURLToPath(import.meta.url));
+}
+
+/** `…/tarsk-improve/scripts` → skill root → parent (bundled-skills or .agents/skills). */
+function skillPackageParent(): string {
+  return resolve(scriptDir(), "../..");
+}
+
+function looksLikeBundledRoot(dir: string): boolean {
+  return (
+    existsSync(join(dir, "tarsk-read", "SKILL.md")) ||
+    existsSync(join(dir, "tarsk-agent", "SKILL.md"))
+  );
+}
+
+function resolveBundledRoot(flag?: string): string | null {
+  if (flag) {
+    const resolved = resolve(flag);
+    return existsSync(resolved) ? resolved : null;
+  }
+  if (process.env.TARSK_BUNDLED_SKILLS) {
+    const fromEnv = resolve(process.env.TARSK_BUNDLED_SKILLS);
+    if (existsSync(fromEnv)) return fromEnv;
+  }
+  const parent = skillPackageParent();
+  // Prefer the checkout's built-in tree. The script's own package parent is last:
+  // in a project copy that parent *is* `.agents/skills`, the export target.
+  const candidates = [
+    join(process.cwd(), "cli", "bundled-skills"),
+    join(process.cwd(), "bundled-skills"),
+    join(process.cwd(), "dist", "bundled-skills"),
+    parent,
+  ];
+  for (const candidate of candidates) {
+    if (candidate === resolveProjectSkillsDir()) continue;
+    if (looksLikeBundledRoot(candidate)) return candidate;
+  }
+  return null;
+}
+
+function resolveProjectSkillsDir(flag?: string): string {
+  if (flag) return resolve(flag);
+  const parent = skillPackageParent();
+  // Already living under the project's .agents/skills/tarsk-improve
+  if (basename(parent) === "skills" && basename(dirname(parent)) === ".agents") {
+    return parent;
+  }
+  return join(process.cwd(), ".agents", "skills");
+}
+
+function printHuman(result: ExportToolSkillsResult): void {
+  console.log("# Tool skill export");
+  console.log(`bundled: ${result.bundledRoot ?? "(missing)"}`);
+  console.log(`project: ${result.projectSkillsDir}`);
+  if (result.skipped === "tarsk-checkout") {
+    console.log("");
+    console.log("Tarsk checkout: the built-ins are this repo's own files, so nothing was copied.");
+    console.log(`Edit cli/bundled-skills/tarsk-* directly (${result.bundledRoot}).`);
+    return;
+  }
+  console.log(`copied: ${result.copied.length ? result.copied.join(", ") : "(none)"}`);
+  console.log(
+    `overwritten: ${result.overwritten.length ? result.overwritten.join(", ") : "(none)"}`,
+  );
+  console.log(`left (already present): ${result.left.length}`);
+  console.log("");
+  console.log("## Editable Tool skills (project copies)");
+  if (result.editableToolSkills.length === 0) {
+    console.log("(none — export may have failed; re-run the export command above)");
+    return;
+  }
+  for (const name of result.editableToolSkills) {
+    console.log(`- ${join(result.projectSkillsDir, name)}`);
+  }
+  console.log("");
+  console.log(
+    "Edit only these project paths. Do not edit cli/bundled-skills or other built-in roots.",
+  );
+}
+
+function printPruneHuman(result: ToolSkillPruneResult): void {
+  console.log("# Tool skill prune");
+  console.log(`bundled: ${result.bundledRoot ?? "(missing)"}`);
+  console.log(`project: ${result.projectSkillsDir}`);
+  console.log(
+    `removed (matched bundled): ${result.removed.length ? result.removed.join(", ") : "(none)"}`,
+  );
+  console.log(`kept (differs): ${result.kept.length ? result.kept.join(", ") : "(none)"}`);
+  console.log("");
+  console.log("## Editable Tool skills (project copies that differ)");
+  if (result.editableToolSkills.length === 0) {
+    console.log("(none — no project Tool skill differs from bundled yet)");
+    return;
+  }
+  for (const name of result.editableToolSkills) {
+    console.log(`- ${join(result.projectSkillsDir, name)}`);
+  }
+}
+
+function printExportResult(result: ExportToolSkillsResult, asJson: boolean): void {
+  if (asJson) console.log(JSON.stringify(result, null, 2));
+  else printHuman(result);
+}
+
+function printPruneResult(result: ToolSkillPruneResult, asJson: boolean): void {
+  if (asJson) console.log(JSON.stringify(result, null, 2));
+  else printPruneHuman(result);
+}
+
+/**
+ * Fallback when no bundled-skills root can be found: report the project copies
+ * already on disk without comparing. Returns the process exit code (0 when at
+ * least one editable Tool skill exists).
+ */
+async function reportMissingBundledRoot(
+  projectSkillsDir: string,
+  options: { prune: boolean; asJson: boolean },
+): Promise<number> {
+  console.error(
+    "Could not find bundled-skills. Pass --bundled <dir> or set TARSK_BUNDLED_SKILLS. " +
+      "If Tool skills are already under .agents/skills, list them and continue editing those copies.",
+  );
+  const existing = await listEditableToolSkills(projectSkillsDir);
+  if (options.prune) {
+    printPruneResult(
+      {
+        removed: [],
+        kept: existing,
+        editableToolSkills: existing,
+        projectSkillsDir,
+        bundledRoot: null,
+      },
+      options.asJson,
+    );
+  } else {
+    printExportResult(
+      {
+        copied: [],
+        overwritten: [],
+        left: existing,
+        editableToolSkills: existing,
+        projectSkillsDir,
+        bundledRoot: null,
+      },
+      options.asJson,
+    );
+  }
+  return existing.length > 0 ? 0 : 1;
+}
+
+async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.error(`Usage:
+  bun …/tarsk-improve/scripts/ensure-exported.ts [--project-skills <dir>] [--bundled <dir>] [--prune] [--json]
+`);
+    process.exit(0);
+  }
+
+  const asJson = argv.includes("--json");
+  const prune = argv.includes("--prune");
+  const projectSkillsDir = resolveProjectSkillsDir(readFlagValue(argv, "--project-skills"));
+  const bundledRoot = resolveBundledRoot(readFlagValue(argv, "--bundled"));
+  if (!bundledRoot) {
+    process.exit(await reportMissingBundledRoot(projectSkillsDir, { prune, asJson }));
+  }
+
+  if (prune) {
+    const result = await pruneUnchangedToolSkills(bundledRoot, projectSkillsDir);
+    printPruneResult(result, asJson);
+    return;
+  }
+
+  if (isTarskCheckout(bundledRoot) && !asJson) {
+    console.log("# Tool skill export");
+    console.log(`bundled: ${bundledRoot}`);
+    console.log(`project: ${projectSkillsDir}`);
+    console.log("");
+    console.log("Tarsk checkout: the built-ins are this repo's own files, so nothing was copied.");
+    console.log(`Edit cli/bundled-skills/tarsk-* directly (${bundledRoot}).`);
+    return;
+  }
+
+  const result = await exportToolSkillsFrom(bundledRoot, projectSkillsDir);
+  printExportResult(result, asJson);
+}
+
+if (import.meta.main) {
+  await main();
+}

package/dist/bundled-skills/tarsk-improve/scripts/export-tool-skills-lib.ts

@@ -0,0 +1,299 @@
+// @ts-nocheck — bun script outside cli/tsconfig (no Node/Bun types in staged vp check)
+/**
+ * Shared Tool skill export rules used by both the host (`export-tool-skills.ts`)
+ * and this skill's `ensure-exported.ts`.
+ *
+ * - `exportToolSkillsFrom` copies `tarsk-*` copies for editing (deliberate).
+ * - `pruneUnchangedToolSkills` deletes copies that match bundled, so the repo
+ *   only ever keeps `tarsk-*` skills that actually differ from the built-in.
+ *
+ * In the Tarsk checkout the built-ins *are* the repo's own files, so
+ * `exportToolSkillsFrom` copies nothing (`skipped: "tarsk-checkout"`);
+ * `isTarskCheckout` is how every caller tells the two repos apart.
+ */
+
+import { cp, mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export type ExportAction = "copy" | "overwrite" | "leave";
+
+export interface ExportToolSkillsResult {
+  copied: string[];
+  overwritten: string[];
+  left: string[];
+  /** Project dirs for Skills that publish Tools (have front matter `tools:`). */
+  editableToolSkills: string[];
+  projectSkillsDir: string;
+  bundledRoot: string | null;
+  /** Set when nothing was copied because the built-ins live in this repo. */
+  skipped?: "tarsk-checkout";
+}
+
+function readPackageName(manifestPath: string): string | null {
+  if (!existsSync(manifestPath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    return typeof parsed.name === "string" ? parsed.name : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * True only in the Tarsk checkout itself: `<bundledRoot>/..` is the `tarsk` CLI
+ * package, or its parent is the `tarsk-monorepo` root. Every user project fails
+ * this, so a user's repo still gets real project copies to edit.
+ */
+export function isTarskCheckout(bundledRoot: string): boolean {
+  const cliDir = resolve(bundledRoot, "..");
+  if (readPackageName(join(cliDir, "package.json")) === "tarsk") return true;
+  return readPackageName(join(cliDir, "..", "package.json")) === "tarsk-monorepo";
+}
+
+function parseSemver(
+  version: string | undefined,
+): { major: number; minor: number; patch: number } | null {
+  if (!version) return null;
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+}
+
+/**
+ * Decide whether to copy, overwrite, or leave a project Skill alone.
+ * Missing project → copy. Equal version → leave. Bundled major higher → overwrite. Else leave.
+ */
+export function decideExportAction(args: {
+  projectExists: boolean;
+  bundledVersion: string | undefined;
+  projectVersion: string | undefined;
+}): ExportAction {
+  if (!args.projectExists) return "copy";
+  if (args.bundledVersion === args.projectVersion) return "leave";
+  const bundled = parseSemver(args.bundledVersion);
+  const project = parseSemver(args.projectVersion);
+  if (bundled && project && bundled.major > project.major) return "overwrite";
+  return "leave";
+}
+
+function parseFrontmatter(content: string): Record<string, unknown> {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const metadata: Record<string, unknown> = {};
+  let currentList: string[] | null = null;
+  let currentKey: string | null = null;
+  for (const rawLine of match[1].split("\n")) {
+    const line = rawLine.trimEnd();
+    const listItem = line.match(/^\s*-\s+(.+)$/);
+    if (listItem && currentKey) {
+      if (!currentList) {
+        currentList = [];
+        metadata[currentKey] = currentList;
+      }
+      currentList.push(listItem[1].replace(/^["']|["']$/g, ""));
+      continue;
+    }
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!kv) continue;
+    currentKey = kv[1];
+    currentList = null;
+    const value = kv[2].trim();
+    if (value === "" || value === "|" || value === ">") {
+      currentList = [];
+      metadata[currentKey] = currentList;
+      continue;
+    }
+    metadata[currentKey] = value.replace(/^["']|["']$/g, "");
+  }
+  return metadata;
+}
+
+async function readSkillMeta(skillDir: string): Promise<{ version?: string; tools: string[] }> {
+  const skillFile = join(skillDir, "SKILL.md");
+  if (!existsSync(skillFile)) return { tools: [] };
+  const content = await readFile(skillFile, "utf-8");
+  const meta = parseFrontmatter(content);
+  const tools = Array.isArray(meta.tools)
+    ? meta.tools.filter((item): item is string => typeof item === "string")
+    : [];
+  const version = typeof meta.version === "string" ? meta.version : undefined;
+  return { version, tools };
+}
+
+async function skillPublishesTools(skillDir: string): Promise<boolean> {
+  const meta = await readSkillMeta(skillDir);
+  return meta.tools.length > 0;
+}
+
+/**
+ * Export bundled `tarsk-*` Skills from `bundledRoot` into `projectSkillsDir`.
+ */
+export async function exportToolSkillsFrom(
+  bundledRoot: string,
+  projectSkillsDir: string,
+): Promise<ExportToolSkillsResult> {
+  const result: ExportToolSkillsResult = {
+    copied: [],
+    overwritten: [],
+    left: [],
+    editableToolSkills: [],
+    projectSkillsDir,
+    bundledRoot,
+  };
+  if (!existsSync(bundledRoot)) {
+    return result;
+  }
+  if (isTarskCheckout(bundledRoot)) {
+    // The built-ins are the repo's own files here; a project copy would only
+    // duplicate them and add noise to `git status`.
+    return { ...result, skipped: "tarsk-checkout" };
+  }
+
+  await mkdir(projectSkillsDir, { recursive: true });
+  const entries = await readdir(bundledRoot, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("tarsk-")) continue;
+
+    const bundledDir = join(bundledRoot, entry.name);
+    const projectDir = join(projectSkillsDir, entry.name);
+    const bundledMeta = await readSkillMeta(bundledDir);
+    const projectExists = existsSync(projectDir);
+    const projectMeta = projectExists ? await readSkillMeta(projectDir) : { tools: [] };
+    const action = decideExportAction({
+      projectExists,
+      bundledVersion: bundledMeta.version,
+      projectVersion: projectMeta.version,
+    });
+
+    if (action === "leave") {
+      result.left.push(entry.name);
+    } else {
+      if (projectExists) {
+        await rm(projectDir, { recursive: true, force: true });
+      }
+      await cp(bundledDir, projectDir, { recursive: true });
+      if (action === "copy") {
+        result.copied.push(entry.name);
+      } else {
+        result.overwritten.push(entry.name);
+      }
+    }
+
+    const editableDir = join(projectSkillsDir, entry.name);
+    if (existsSync(editableDir) && (await skillPublishesTools(editableDir))) {
+      result.editableToolSkills.push(entry.name);
+    }
+  }
+
+  result.editableToolSkills.sort((a, b) => a.localeCompare(b));
+  return result;
+}
+
+export interface ToolSkillPruneResult {
+  /** Project copies deleted because they matched the bundled Skill byte-for-byte. */
+  removed: string[];
+  /** Project copies retained because they differ from the bundled Skill. */
+  kept: string[];
+  /** Retained project copies that publish Tools (front matter `tools:`). */
+  editableToolSkills: string[];
+  projectSkillsDir: string;
+  bundledRoot: string | null;
+}
+
+/** Sorted relative file paths of every regular file under `dir` (recursive). */
+async function listRelativeFiles(dir: string, base = ""): Promise<string[]> {
+  const out: string[] = [];
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      out.push(...(await listRelativeFiles(join(dir, entry.name), rel)));
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+  return out.sort();
+}
+
+/** True when two Skill directories hold the same files with identical bytes. */
+async function dirsEqual(a: string, b: string): Promise<boolean> {
+  const aFiles = await listRelativeFiles(a);
+  const bFiles = await listRelativeFiles(b);
+  if (aFiles.length !== bFiles.length) return false;
+  for (let index = 0; index < aFiles.length; index += 1) {
+    if (aFiles[index] !== bFiles[index]) return false;
+  }
+  for (const rel of aFiles) {
+    const [contentA, contentB] = await Promise.all([
+      readFile(join(a, rel)),
+      readFile(join(b, rel)),
+    ]);
+    if (!contentA.equals(contentB)) return false;
+  }
+  return true;
+}
+
+/**
+ * Delete `tarsk-*` project copies that still match the bundled Skill exactly.
+ * Never creates a copy: a project Skill exists only because someone edited it.
+ * Copies that differ from bundled are kept.
+ */
+export async function pruneUnchangedToolSkills(
+  bundledRoot: string,
+  projectSkillsDir: string,
+): Promise<ToolSkillPruneResult> {
+  const result: ToolSkillPruneResult = {
+    removed: [],
+    kept: [],
+    editableToolSkills: [],
+    projectSkillsDir,
+    bundledRoot,
+  };
+  if (!existsSync(projectSkillsDir)) {
+    return result;
+  }
+
+  for (const entry of await readdir(projectSkillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("tarsk-")) continue;
+
+    const projectDir = join(projectSkillsDir, entry.name);
+    const bundledDir = join(bundledRoot, entry.name);
+    if (existsSync(bundledDir) && (await dirsEqual(projectDir, bundledDir))) {
+      await rm(projectDir, { recursive: true, force: true });
+      result.removed.push(entry.name);
+      continue;
+    }
+
+    result.kept.push(entry.name);
+    if (await skillPublishesTools(projectDir)) {
+      result.editableToolSkills.push(entry.name);
+    }
+  }
+
+  const byName = (a: string, b: string): number => a.localeCompare(b);
+  result.removed.sort(byName);
+  result.kept.sort(byName);
+  result.editableToolSkills.sort(byName);
+  return result;
+}
+
+/**
+ * List `tarsk-*` project Skills that publish Tools (have front matter `tools:`).
+ */
+export async function listEditableToolSkills(projectSkillsDir: string): Promise<string[]> {
+  if (!existsSync(projectSkillsDir)) return [];
+  const names: string[] = [];
+  for (const entry of await readdir(projectSkillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("tarsk-")) continue;
+    if (await skillPublishesTools(join(projectSkillsDir, entry.name))) {
+      names.push(entry.name);
+    }
+  }
+  names.sort((a, b) => a.localeCompare(b));
+  return names;
+}

package/dist/bundled-skills/tarsk-improve/scripts/summarize-session.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env bun
+// @ts-nocheck — bun script outside cli/tsconfig (no Node/Bun types in staged vp check)
+/**
+ * Summarize Tarsk agent runs for tarsk-improve: tool failures, repeats, and
+ * turn/token waste that point at Tool skill fixes.
+ *
+ * Usage (from project root, after ensure-exported):
+ *   bun .agents/skills/tarsk-improve/scripts/summarize-session.ts
+ *   bun .agents/skills/tarsk-improve/scripts/summarize-session.ts --conversation <id>
+ *   bun .agents/skills/tarsk-improve/scripts/summarize-session.ts --since 24h
+ */
+
+import {
+  COMMON_USAGE_FLAGS,
+  abortedCallCount,
+  cacheReadPercent,
+  failedCalls,
+  failureDetail,
+  formatContextTrend,
+  formatStopReasons,
+  formatToolHistogram,
+  isProjectConfigToolCall,
+  largestResults,
+  loadRunsFromArgs,
+  printNoRunsHint,
+  printRunHeader,
+  repeatedCallCount,
+  retriesAfterFailureCount,
+  toolHistogram,
+  type Run,
+} from "./durable-runs.js";
+
+const MAX_FAILURES_SHOWN = 12;
+
+function printUsage(): void {
+  console.error(`Usage:
+  bun .agents/skills/tarsk-improve/scripts/summarize-session.ts [options]
+
+Summarizes recent agent runs from tarsk.db for Tool skill improvement.
+
+${COMMON_USAGE_FLAGS}
+`);
+}
+
+/** Higher = more waste. Project-config tool calls are not counted as productive work. */
+export function wasteScore(run: Run): number {
+  const productiveTools = run.calls.filter((call) => !isProjectConfigToolCall(call)).length;
+  return (
+    run.modelCalls +
+    failedCalls(run.calls).length * 2 +
+    retriesAfterFailureCount(run.calls) * 2 +
+    repeatedCallCount(run.calls) +
+    run.providerErrors * 2 +
+    productiveTools * 0.1
+  );
+}
+
+function printRun(run: Run, index: number): void {
+  const projectConfigCalls = run.calls.filter(isProjectConfigToolCall).length;
+  const failures = failedCalls(run.calls);
+  const cachePercent = cacheReadPercent(run);
+
+  console.log(`## Run ${index + 1} (waste score ${wasteScore(run).toFixed(1)})`);
+  printRunHeader(run);
+  console.log(`- duration: ${run.durationSec === undefined ? "?" : `${run.durationSec}s`}`);
+  console.log(`- agent turns (model calls): ${run.modelCalls}`);
+  console.log(`- stop reasons: ${formatStopReasons(run) || "(none)"}`);
+  console.log(`- tool calls: ${run.calls.length}`);
+  console.log(`- project-config tool calls (excluded): ${projectConfigCalls}`);
+  console.log(
+    `- tool failures: ${failures.length} (user aborts not counted: ${abortedCallCount(run.calls)})`,
+  );
+  console.log(`- identical repeated calls: ${repeatedCallCount(run.calls)}`);
+  console.log(`- retried a failed call unchanged: ${retriesAfterFailureCount(run.calls)}`);
+  console.log(`- provider errors: ${run.providerErrors}`);
+  console.log(`- context resets (compaction / rollover): ${run.resets}`);
+  console.log(`- context tokens: ${formatContextTrend(run)}`);
+  console.log(
+    `- cache: read ${cachePercent === undefined ? "n/a" : `${cachePercent}%`} of input, wrote ${run.cacheWriteTokens} tokens`,
+  );
+  console.log(`- output tokens: ${run.outputTokens} (reasoning ${run.reasoningTokens})`);
+  console.log(`- cost: $${run.costTotal.toFixed(4)}`);
+  console.log(`- largest tool results: ${largestResults(run.calls) || "(none)"}`);
+  console.log(`- tools (all): ${formatToolHistogram(toolHistogram(run.calls))}`);
+  console.log(
+    `- tools (excl. project config): ${formatToolHistogram(toolHistogram(run.calls, { exclProjectConfig: true }))}`,
+  );
+  if (failures.length > 0) {
+    console.log(`- failures:`);
+    for (const failure of failures.slice(0, MAX_FAILURES_SHOWN)) {
+      console.log(`  - ${failure.name}: ${failureDetail(failure, 100)}`);
+    }
+  }
+  console.log("");
+}
+
+function main(): void {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printUsage();
+    return;
+  }
+
+  const { runs, args } = loadRunsFromArgs(argv);
+  const withActivity = runs.filter((run) => run.modelCalls > 0);
+  const shown = [...withActivity]
+    .sort((a, b) => wasteScore(b) - wasteScore(a))
+    .slice(0, args.limit);
+
+  console.log(`# Tarsk improve — session summary`);
+  console.log(
+    `Runs loaded: ${runs.length}; with agent activity: ${withActivity.length} (showing top ${shown.length} by waste score)\n`,
+  );
+
+  for (const [index, run] of shown.entries()) {
+    printRun(run, index);
+  }
+
+  if (shown.length === 0) {
+    printNoRunsHint();
+  }
+}
+
+if (import.meta.main) {
+  main();
+}

package/dist/bundled-skills/tarsk-jobs/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: tarsk-jobs
+description: >-
+  Tarsk Tool skill publishing: job_list, job_output, job_kill.
+version: 2.1.0
+tools:
+  - job_list
+  - job_output
+  - job_kill
+disable-model-invocation: true
+---
+
+# tarsk-jobs
+
+Publishes: job_list, job_output, job_kill.
+
+Logic and formatting live in `scripts/`. Owner-scoped registry access and kill
+are `context.jobs` (CLI host).