tines 0.0.89 → 0.0.91

package/dist/index.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 
-// src/program.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-
 // ../../node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
   /**
@@ -4078,6 +4075,36 @@ function runRow(run) {
     timestamp(run.created_at)
   ];
 }
+function byteSize(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = Math.max(0, bytes);
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  const rounded = unit <= 1 ? Math.round(value) : Math.round(value * 10) / 10;
+  return `${unit <= 1 ? rounded : rounded.toFixed(1)} ${units[unit]}`;
+}
+function ageLabel(isoTimestamp, now = Date.now()) {
+  const then = Date.parse(isoTimestamp);
+  if (!Number.isFinite(then)) return "\u2014";
+  const seconds = Math.max(0, Math.round((now - then) / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+function keptWorkspaceRow(kept, sizeBytes, now = Date.now()) {
+  return [
+    kept.run_id,
+    kept.issue_ref ?? "\u2014",
+    kept.status,
+    ageLabel(kept.kept_at, now),
+    byteSize(sizeBytes),
+    kept.path
+  ];
+}
 function formatTable(rows) {
   if (rows.length === 0) return "";
   const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => r[i].length)));
@@ -5501,16 +5528,28 @@ import { hostname as hostname2 } from "node:os";
 import { spawn as spawn2 } from "node:child_process";
 import {
   createWriteStream,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
-  rmSync,
-  statSync as statSync2,
+  readFileSync as readFileSync7,
+  rmSync as rmSync2,
+  statSync as statSync3,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { hostname, platform, arch } from "node:os";
 import { dirname as dirname4, join as join4 } from "node:path";
 
+// src/version.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+function cliVersion() {
+  try {
+    const manifest = new URL("../package.json", import.meta.url);
+    return JSON.parse(readFileSync4(manifest, "utf8")).version ?? "0.0.0-unknown";
+  } catch {
+    return "0.0.0-unknown";
+  }
+}
+
 // src/daemon/claude-stream.ts
 function clip(value, max) {
   return value.length > max ? `${value.slice(0, max)}\u2026` : value;
@@ -5608,12 +5647,16 @@ var ClaudeStreamRenderer = class {
 
 // src/daemon/cli-refresh.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
 
 // src/daemon/support.ts
 import { delimiter } from "node:path";
 var HARNESS_KINDS = ["claude_code", "codex", "custom"];
+var KEEP_WORKSPACES_MODES = ["never", "failed", "always"];
+function keepWorkspace(mode, outcome) {
+  return mode === "always" || mode === "failed" && outcome === "failed";
+}
 function shellQuote(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
@@ -5641,12 +5684,56 @@ function buildHarnessInvocation(spec, input) {
     }
   }
 }
+var LAUNCH_ARG_MAX = 160;
+var SAFE_WORD = /^[A-Za-z0-9_@%+=:,./-]+$/;
+function launchWord(word) {
+  if (word.length > LAUNCH_ARG_MAX)
+    return shellQuote(`${word.slice(0, LAUNCH_ARG_MAX)}\u2026 [+${word.length - LAUNCH_ARG_MAX} chars]`);
+  return SAFE_WORD.test(word) ? word : shellQuote(word);
+}
+function formatLaunchCommand(invocation) {
+  if (invocation.file === "sh" && invocation.args.length === 2 && invocation.args[0] === "-c")
+    return invocation.args[1];
+  return [invocation.file, ...invocation.args].map(launchWord).join(" ");
+}
+function formatLaunchBanner(invocation, input, meta) {
+  const fields = [
+    `harness=${meta.harness}`,
+    `model=${input.model ?? "(fixed)"}`,
+    `timeout=${meta.timeoutMinutes}m`,
+    `cli=${meta.cliVersion}`,
+    `workspace=${input.workspace}`
+  ];
+  return `$ ${formatLaunchCommand(invocation)}
+# tines runner: ${fields.join(" ")}
+`;
+}
+function formatDuration(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1e3));
+  return `${Math.floor(seconds / 60)}m${seconds % 60}s`;
+}
+function formatExitLine(exit) {
+  const parts = [];
+  if (exit.code !== null) parts.push(`code=${exit.code}`);
+  if (exit.signal) parts.push(`signal=${exit.signal}`);
+  if (parts.length === 0) parts.push("code=?");
+  if (exit.timedOut) parts.push("(timed out)");
+  return `# tines runner: exit ${parts.join(" ")} after ${formatDuration(exit.durationMs)}
+`;
+}
+function exitLineForRun(run, exit) {
+  if (run.settled) return null;
+  return formatExitLine({ ...exit, timedOut: run.timedOut });
+}
 var RunTable = class {
-  constructor(effects) {
+  constructor(effects, opts = {}) {
     this.effects = effects;
+    this.keep = opts.keep ?? (() => false);
   }
   effects;
   runs = /* @__PURE__ */ new Map();
+  /** The daemon's keep decision, as data: `keepWorkspace` bound to its mode. */
+  keep;
   get size() {
     return this.runs.size;
   }
@@ -5667,11 +5754,19 @@ var RunTable = class {
   persist() {
     this.effects.persist();
   }
-  /** Removes the run and releases its local traces. Safe to call twice. */
-  cleanup(run) {
+  /**
+   * Removes the run and releases its local traces. Safe to call twice.
+   *
+   * The outcome defaults to `failed` because every route here that is not an
+   * explicit completed finish is a failure: a supervisor cancel (which
+   * reaches cleanup with no status at all), a clone failure on an
+   * already-settled run, a daemon shutdown. Guessing `failed` also errs the
+   * safe way — it keeps a directory rather than destroying evidence.
+   */
+  cleanup(run, outcome = "failed") {
     this.runs.delete(run.runId);
     this.effects.persist();
-    this.effects.release(run);
+    this.effects.release(run, { keep: this.keep(outcome), outcome });
   }
   /**
    * Ends a run: flush logs, finish-report, clean up. On a run someone
@@ -5682,7 +5777,9 @@ var RunTable = class {
   async finishAndCleanup(run, status, error) {
     if (run.settled) return this.cleanup(run);
     run.settled = true;
+    run.endNote ??= error;
     run.drain?.();
+    if (this.keep(status)) this.effects.noteKept?.(run);
     await run.flush?.();
     try {
       await this.effects.finish(run, status, error);
@@ -5692,7 +5789,7 @@ var RunTable = class {
         `finish report for run ${run.runId} not accepted: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    this.cleanup(run);
+    this.cleanup(run, status);
   }
   /**
    * Marks a supervisor-settled run (`cancels`): kill, do NOT finish-report.
@@ -5833,7 +5930,7 @@ function binDirOf(prefix) {
 }
 function installedVersion(prefix) {
   try {
-    const pkg = readFileSync4(join2(prefix, "node_modules", PACKAGE, "package.json"), "utf8");
+    const pkg = readFileSync5(join2(prefix, "node_modules", PACKAGE, "package.json"), "utf8");
     const version = JSON.parse(pkg).version;
     return typeof version === "string" ? version : null;
   } catch {
@@ -5910,7 +6007,15 @@ function message(err) {
 }
 
 // src/daemon/store.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync6,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname3, join as join3 } from "node:path";
 function defaultConfigDir() {
@@ -5919,7 +6024,7 @@ function defaultConfigDir() {
 function readJsonFile(path2) {
   if (!existsSync3(path2)) return null;
   try {
-    return JSON.parse(readFileSync5(path2, "utf8"));
+    return JSON.parse(readFileSync6(path2, "utf8"));
   } catch {
     return null;
   }
@@ -5970,10 +6075,10 @@ function saveDaemonState(path2, runs) {
 }
 function processStartTimeMs(pid) {
   try {
-    const stat = readFileSync5(`/proc/${pid}/stat`, "utf8");
+    const stat = readFileSync6(`/proc/${pid}/stat`, "utf8");
     const afterComm = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
     const startTicks = Number(afterComm[19]);
-    const btimeLine = readFileSync5("/proc/stat", "utf8").split("\n").find((line) => line.startsWith("btime "));
+    const btimeLine = readFileSync6("/proc/stat", "utf8").split("\n").find((line) => line.startsWith("btime "));
     const btime = Number(btimeLine?.slice("btime ".length));
     if (!Number.isFinite(startTicks) || !Number.isFinite(btime)) return null;
     return btime * 1e3 + startTicks / 100 * 1e3;
@@ -5981,18 +6086,93 @@ function processStartTimeMs(pid) {
     return null;
   }
 }
+function workspacesDir(configDir) {
+  return join3(configDir, "workspaces");
+}
+function keptMarkerPath(workspace) {
+  return join3(workspace, "kept.json");
+}
+function writeKeptMarker(workspace, marker) {
+  writeJsonFile(keptMarkerPath(workspace), marker);
+}
+function readKeptMarker(workspace) {
+  const marker = readJsonFile(keptMarkerPath(workspace));
+  if (!marker || typeof marker.run_id !== "string" || typeof marker.kept_at !== "string") {
+    return null;
+  }
+  return marker;
+}
+function listKeptWorkspaces(configDir) {
+  const root = workspacesDir(configDir);
+  let names;
+  try {
+    names = readdirSync2(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  const kept = [];
+  for (const name2 of names) {
+    const path2 = join3(root, name2);
+    const marker = readKeptMarker(path2);
+    if (marker) kept.push({ ...marker, path: path2 });
+  }
+  return kept.sort((a, b) => Date.parse(b.kept_at) - Date.parse(a.kept_at));
+}
+function pruneKeptWorkspaces(configDir, opts) {
+  const kept = listKeptWorkspaces(configDir);
+  const now = (opts.now ?? Date.now)();
+  const doomed = [];
+  const survivors = [];
+  for (const entry of kept) {
+    const age = now - Date.parse(entry.kept_at);
+    const expired = opts.maxAgeMs !== void 0 && Number.isFinite(age) && age > opts.maxAgeMs;
+    if (opts.all || expired) doomed.push(entry);
+    else survivors.push(entry);
+  }
+  if (!opts.all && opts.maxCount !== void 0) doomed.push(...survivors.slice(opts.maxCount));
+  const removed = [];
+  for (const entry of doomed) {
+    try {
+      rmSync(entry.path, { recursive: true, force: true });
+      removed.push(entry);
+    } catch {
+    }
+  }
+  return removed;
+}
+function directorySizeBytes(path2) {
+  let total = 0;
+  let entries;
+  try {
+    entries = readdirSync2(path2, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const child = join3(path2, entry.name);
+    if (entry.isDirectory()) total += directorySizeBytes(child);
+    else if (entry.isFile()) {
+      try {
+        total += statSync2(child).size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
 
 // src/daemon/daemon.ts
 var CLI_REFRESH_TTL_MS = 10 * 6e4;
+var DAEMON_VERSION = cliVersion();
 async function uploadRawLog(run) {
   const path2 = run.rawSpoolPath;
   if (!path2 || !run.rawUpload) return;
   run.rawSpoolPath = void 0;
   try {
     await new Promise((resolve) => run.rawSpool?.end(resolve) ?? resolve());
-    const size = statSync2(path2).size;
+    const size = statSync3(path2).size;
     if (size > 0) {
-      let body = readFileSync6(path2);
+      let body = readFileSync7(path2);
       if (body.byteLength > RUN_LOG_RAW_MAX_BYTES) {
         const marker = Buffer.from(
           `{"type":"tines_truncated","dropped_bytes":${body.byteLength - RUN_LOG_RAW_MAX_BYTES}}
@@ -6032,6 +6212,34 @@ function pidAlive(pid) {
 }
 async function runDaemon(opts) {
   mkdirSync4(opts.configDir, { recursive: true });
+  mkdirSync4(workspacesDir(opts.configDir), { recursive: true, mode: 448 });
+  const sweepKeptWorkspaces = () => {
+    const removed = pruneKeptWorkspaces(opts.configDir, {
+      maxAgeMs: opts.keepWorkspacesForHours * 36e5,
+      maxCount: opts.keepWorkspacesMax
+    });
+    if (removed.length > 0) {
+      log(
+        `pruned ${removed.length} kept workspace(s) past retention (${opts.keepWorkspacesForHours}h, max ${opts.keepWorkspacesMax})`
+      );
+    }
+  };
+  sweepKeptWorkspaces();
+  const settleWorkspace = (workspace, keep, marker) => {
+    if (!keep) {
+      rmSync2(workspace, { recursive: true, force: true });
+      return;
+    }
+    if (!existsSync4(workspace)) return;
+    try {
+      writeKeptMarker(workspace, { ...marker, kept_at: (/* @__PURE__ */ new Date()).toISOString() });
+      log(`run ${marker.run_id}: workspace kept at ${workspace}`);
+    } catch (err) {
+      log(
+        `run ${marker.run_id}: workspace kept at ${workspace}, but kept.json could not be written (${message2(err)})`
+      );
+    }
+  };
   let creds = loadRunnerCredentials(opts.configDir, opts.url, opts.name);
   if (creds) {
     log(`reconnecting as runner "${opts.name}" (${creds.runner_id}) \u2014 token from ${opts.configDir}`);
@@ -6067,24 +6275,33 @@ async function runDaemon(opts) {
     finish: async (run, status, error) => {
       await client2.finishRun(run.runId, { status, ...error ? { error } : {} });
     },
-    release: (run) => {
+    release: (run, { keep, outcome }) => {
       if (run.timeout) clearTimeout(run.timeout);
       run.renderer?.finish();
-      rmSync(run.workspace, { recursive: true, force: true });
+      settleWorkspace(run.workspace, keep, {
+        run_id: run.runId,
+        ...run.issueLabel ? { issue_ref: run.issueLabel } : {},
+        status: outcome,
+        ...run.endNote ? { error: run.endNote } : {}
+      });
       void uploadRawLog(run);
+      sweepKeptWorkspaces();
     },
+    noteKept: (run) => run.batcher.append(`workspace kept at ${run.workspace}
+`),
     persist: () => {
       const entries = table2.values().filter((run) => run.child?.pid !== void 0).map((run) => ({
         run_id: run.runId,
         pid: run.child.pid,
         workspace: run.workspace,
         key_fingerprint: run.keyFingerprint,
-        started_at: run.spawnedAt
+        started_at: run.spawnedAt,
+        ...run.issueLabel ? { issue_ref: run.issueLabel } : {}
       }));
       saveDaemonState(statePath, entries);
     },
     log
-  });
+  }, { keep: (outcome) => keepWorkspace(opts.keepWorkspaces, outcome) });
   for (const orphan of loadDaemonState(statePath)) {
     if (pidAlive(orphan.pid)) {
       const processStart = processStartTimeMs(orphan.pid);
@@ -6103,12 +6320,18 @@ async function runDaemon(opts) {
       });
     } catch {
     }
-    rmSync(orphan.workspace, { recursive: true, force: true });
+    settleWorkspace(orphan.workspace, keepWorkspace(opts.keepWorkspaces, "failed"), {
+      run_id: orphan.run_id,
+      ...orphan.issue_ref ? { issue_ref: orphan.issue_ref } : {},
+      status: "failed",
+      error: "daemon restarted; orphaned harness killed"
+    });
   }
   saveDaemonState(statePath, []);
   const killWithoutFinish = (runId) => {
     const run = table2.markCanceled(runId);
     if (!run) return;
+    run.endNote ??= "canceled by supervisor";
     log(`supervisor canceled run ${runId}; killing without finish-reporting`);
     if (run.child?.pid) {
       const pid = run.child.pid;
@@ -6119,10 +6342,12 @@ async function runDaemon(opts) {
   const launch = async (assignment) => {
     const runId = assignment.run.id;
     if (table2.has(runId)) return;
-    const workspace = join4(opts.configDir, "workspaces", runId);
+    const workspace = join4(workspacesDir(opts.configDir), runId);
+    const issueLabel = assignment.run.issue_ref ? `${assignment.run.issue_ref.project_name}/${assignment.run.issue_ref.number}` : void 0;
     const run = {
       runId,
       workspace,
+      ...issueLabel ? { issueLabel } : {},
       canceled: false,
       timedOut: false,
       settled: false,
@@ -6135,9 +6360,9 @@ async function runDaemon(opts) {
     };
     run.flush = () => run.batcher.flush();
     table2.track(run);
-    log(`run ${runId} assigned (issue ${assignment.run.issue_ref ? `${assignment.run.issue_ref.project_name}/${assignment.run.issue_ref.number}` : assignment.run.issue_id}); materializing workspace`);
+    log(`run ${runId} assigned (issue ${issueLabel ?? assignment.run.issue_id}); materializing workspace`);
     try {
-      rmSync(workspace, { recursive: true, force: true });
+      rmSync2(workspace, { recursive: true, force: true });
       mkdirSync4(workspace, { recursive: true });
       writeFileSync3(join4(workspace, "prompt.md"), `${assignment.prompt}
 `);
@@ -6172,14 +6397,22 @@ async function runDaemon(opts) {
 ` : `warning: no daemon-managed tines CLI; using whatever \`tines\` is on this machine's PATH
 `
       );
+      const harnessInput = {
+        workspace,
+        promptFile: join4(workspace, "prompt.md"),
+        prompt: assignment.prompt,
+        model: assignment.run.model
+      };
       const invocation = buildHarnessInvocation(
         { harness: opts.harness, command: opts.command },
-        {
-          workspace,
-          promptFile: join4(workspace, "prompt.md"),
-          prompt: assignment.prompt,
-          model: assignment.run.model
-        }
+        harnessInput
+      );
+      run.batcher.append(
+        formatLaunchBanner(invocation, harnessInput, {
+          harness: opts.harness,
+          timeoutMinutes: assignment.timeout_minutes,
+          cliVersion: DAEMON_VERSION
+        })
       );
       const child = spawn2(invocation.file, invocation.args, {
         cwd: workspace,
@@ -6226,6 +6459,13 @@ async function runDaemon(opts) {
         void table2.finishAndCleanup(run, "failed", `failed to launch harness: ${message2(err)}`);
       });
       child.on("exit", (code, signal) => {
+        run.drain?.();
+        const closing = exitLineForRun(run, {
+          code,
+          signal,
+          durationMs: Date.now() - (run.spawnedAt ?? Date.now())
+        });
+        if (closing) run.batcher.append(closing);
         if (run.timedOut) {
           void table2.finishAndCleanup(
             run,
@@ -6284,7 +6524,12 @@ async function runDaemon(opts) {
       if (err instanceof ApiError && err.status === 401) {
         for (const run of table2.values()) {
           if (run.child?.pid) killTree(run.child.pid, "SIGKILL");
-          rmSync(run.workspace, { recursive: true, force: true });
+          settleWorkspace(run.workspace, keepWorkspace(opts.keepWorkspaces, "failed"), {
+            run_id: run.runId,
+            ...run.issueLabel ? { issue_ref: run.issueLabel } : {},
+            status: "failed",
+            error: "daemon token rejected"
+          });
         }
         saveDaemonState(statePath, []);
         clearRunnerCredentials(opts.configDir, opts.url, opts.name);
@@ -6522,6 +6767,20 @@ function register6(program3) {
     runnerCmd.command("daemon").description("Run the local runner daemon: register/reconnect, poll for assigned runs, execute them").option("--name <name>", "runner name, unique per user (default: this hostname)").option("--harness <harness>", "claude-code | codex | custom", "claude-code").option("--command <template>", "custom harness command template ({prompt_file}, {workspace}, {model})").option("--max-concurrent <n>", "maximum simultaneous runs", (v) => Number.parseInt(v, 10), 1).option("--poll-interval <seconds>", "seconds between polls", (v) => Number.parseInt(v, 10), 15).option(
       "--no-cli-refresh",
       "do not install/refresh the agent-facing tines CLI from npm (harnesses use the ambient PATH)"
+    ).option(
+      "--keep-workspaces <mode>",
+      "keep settled runs' workspaces for debugging: never | failed | always",
+      "never"
+    ).option(
+      "--keep-workspaces-for <hours>",
+      "delete kept workspaces older than this",
+      (v) => Number(v),
+      72
+    ).option(
+      "--keep-workspaces-max <n>",
+      "keep at most this many workspaces (oldest removed first)",
+      (v) => Number.parseInt(v, 10),
+      20
     )
   ).action(
     async (opts) => {
@@ -6539,6 +6798,16 @@ function register6(program3) {
       if (!Number.isInteger(opts.pollInterval) || opts.pollInterval < 1) {
         die("--poll-interval must be a positive number of seconds");
       }
+      const keepWorkspaces = opts.keepWorkspaces;
+      if (!KEEP_WORKSPACES_MODES.includes(keepWorkspaces)) {
+        die(`--keep-workspaces must be ${KEEP_WORKSPACES_MODES.join(", ")}, got "${opts.keepWorkspaces}"`);
+      }
+      if (!Number.isFinite(opts.keepWorkspacesFor) || opts.keepWorkspacesFor <= 0) {
+        die("--keep-workspaces-for must be a positive number of hours");
+      }
+      if (!Number.isInteger(opts.keepWorkspacesMax) || opts.keepWorkspacesMax < 1) {
+        die("--keep-workspaces-max must be a positive integer");
+      }
       await runDaemon({
         url: resolveUrl(opts).replace(/\/+$/, ""),
         apiKey: resolveApiKey(opts),
@@ -6548,10 +6817,45 @@ function register6(program3) {
         maxConcurrent: opts.maxConcurrent,
         pollIntervalMs: opts.pollInterval * 1e3,
         configDir: defaultConfigDir(),
-        cliRefresh: opts.cliRefresh
+        cliRefresh: opts.cliRefresh,
+        keepWorkspaces,
+        keepWorkspacesForHours: opts.keepWorkspacesFor,
+        keepWorkspacesMax: opts.keepWorkspacesMax
       });
     }
   );
+  const workspacesCmd = runnerCmd.command("workspaces").description("List run workspaces the daemon kept for debugging (--keep-workspaces)").option("--json", "print JSON instead of a table").action((opts) => {
+    const configDir = defaultConfigDir();
+    const kept = listKeptWorkspaces(configDir);
+    const sized = kept.map((k) => ({ ...k, size_bytes: directorySizeBytes(k.path) }));
+    if (opts.json) return printJson({ items: sized });
+    if (sized.length === 0) {
+      console.log(`no kept workspaces in ${workspacesDir(configDir)}`);
+      return console.log(
+        "the daemon keeps them only with --keep-workspaces failed (or always)."
+      );
+    }
+    table([
+      ["RUN", "ISSUE", "STATUS", "AGE", "SIZE", "PATH"],
+      ...sized.map((k) => keptWorkspaceRow(k, k.size_bytes))
+    ]);
+  });
+  workspacesCmd.command("prune").description("Delete kept workspaces (never touches a live run's workspace)").option("--all", "delete every kept workspace").option("--older-than <hours>", "delete kept workspaces older than this", (v) => Number(v)).option("--json", "print JSON instead of a table").action((opts) => {
+    if (opts.all === void 0 && opts.olderThan === void 0) {
+      die("pass --all or --older-than <hours>");
+    }
+    if (opts.all && opts.olderThan !== void 0) die("--all cannot be combined with --older-than");
+    if (opts.olderThan !== void 0 && (!Number.isFinite(opts.olderThan) || opts.olderThan < 0)) {
+      die("--older-than must be a non-negative number of hours");
+    }
+    const removed = pruneKeptWorkspaces(defaultConfigDir(), {
+      all: opts.all,
+      ...opts.olderThan !== void 0 ? { maxAgeMs: opts.olderThan * 36e5 } : {}
+    });
+    if (opts.json) return printJson({ items: removed });
+    for (const entry of removed) console.log(`removed ${entry.path}`);
+    console.log(`pruned ${removed.length} kept workspace${removed.length === 1 ? "" : "s"}`);
+  });
   const runsCmd = program3.command("runs").description("Agent runs: attempts at issues by runners");
   withList(
     runsCmd.command("list").description("List runs, newest first").option("-i, --issue <ref>", "filter to one issue (<project>/<number>)").option("-r, --runner <name>", "filter by runner name").option("--active", "only runs holding a claim (assigned/launching/running)")
@@ -6899,7 +7203,7 @@ function register8(program3) {
 }
 
 // src/commands/workflows.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 function readJsonBody(inline, file) {
   if (inline !== void 0 && file !== void 0) {
     die("pass the JSON inline or with --file, not both");
@@ -6908,14 +7212,14 @@ function readJsonBody(inline, file) {
   if (file !== void 0 && file !== "-") {
     let raw;
     try {
-      raw = readFileSync7(file, "utf8");
+      raw = readFileSync8(file, "utf8");
     } catch (err) {
       die(`cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
     }
     return parseJsonObject(raw, file);
   }
   if (file === "-" || !process.stdin.isTTY) {
-    const raw = readFileSync7(0, "utf8");
+    const raw = readFileSync8(0, "utf8");
     if (raw.trim() === "") {
       if (file === "-") die("no JSON on stdin");
       return void 0;
@@ -7069,14 +7373,6 @@ see \`tines workflows create --help\` for the expected shape`
 }
 
 // src/program.ts
-function cliVersion() {
-  try {
-    const manifest = new URL("../package.json", import.meta.url);
-    return JSON.parse(readFileSync8(manifest, "utf8")).version ?? "0.0.0-unknown";
-  } catch {
-    return "0.0.0-unknown";
-  }
-}
 var program2 = new Command();
 program2.name("tines").description("CLI for Tines").version(cliVersion()).enablePositionalOptions();
 registerTime(program2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.89",
+  "version": "0.0.91",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",