tarsk 0.6.87 → 0.6.88

package/dist/bundled-skills/tarsk-improve/scripts/durable-runs.ts

@@ -0,0 +1,635 @@
+// @ts-nocheck — bun script outside cli/tsconfig (no Node/Bun types in staged vp check)
+/**
+ * Shared reader for tarsk-improve (and compatible with the learn skill helpers).
+ *
+ * Reads agent runs straight from Tarsk's durable conversation store in
+ * `tarsk.db` (pi-durable `entries` table) — no log file or JSONL export needed.
+ *
+ * A **run** is one `pi.user` entry plus everything the agent did before the
+ * next `pi.user` entry in the same durable conversation: model calls
+ * (`pi.assistant`), tool results (`pi.tool-result`), and context resets
+ * (`pi.reset`).
+ *
+ * The database is opened read-only, so it is safe while Tarsk is running.
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export const DEFAULT_SCAN = 300;
+export const DEFAULT_LIMIT = 8;
+
+const CONTINUATION_PROMPT_RE = /^You stopped before finishing the current task/i;
+const ABORTED_RE = /was aborted/i;
+const DURATION_UNITS_MS: Record<string, number> = {
+  m: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+};
+
+/** Paths and tools tied to project agent config — excluded from scoring. */
+const PROJECT_CONFIG_PATH_RE =
+  /(?:\.agents\/(?:skills|rules|slash-commands)|\/SKILL\.md|AGENTS\.md|\.cursor\/rules|slash-commands)/i;
+
+const PROJECT_CONFIG_TOOLS = new Set([
+  "read_skill",
+  "read_skill_reference",
+  "execute_skill_script",
+]);
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  args: Record<string, unknown>;
+  /** `name` + serialized args, for spotting identical repeats. */
+  signature: string;
+  /** Size of the stored tool-result record, in bytes. Undefined until a result arrives. */
+  resultBytes?: number;
+  /** True when the tool returned an error that was not a user abort. */
+  isError: boolean;
+  /** True when the user (or a crash/restart) aborted the call. */
+  aborted: boolean;
+  /** First part of the tool result text, kept for failures only. */
+  errorText?: string;
+}
+
+export interface Run {
+  entryId: number;
+  durableConversationId: number;
+  threadId?: string;
+  conversationId?: string;
+  /** Set when this durable conversation is a child (subagent) of another. */
+  ownerConversationId?: number;
+  startedAt?: string;
+  startedAtMs?: number;
+  durationSec?: number;
+  prompt: string;
+  /** True for the automatic "You stopped before finishing…" nudge. */
+  continuation: boolean;
+  model?: string;
+  provider?: string;
+  modelCalls: number;
+  /** Counts by assistant stopReason (stop, toolUse, error, aborted, length…). */
+  stopReasons: Map<string, number>;
+  providerErrors: number;
+  calls: ToolCall[];
+  resets: number;
+  /** Per-model-call context size: input + cacheRead + cacheWrite tokens. */
+  contextTokens: number[];
+  uncachedInputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+  costTotal: number;
+}
+
+export interface CommonArgs {
+  dbPath: string;
+  scan: number;
+  limit: number;
+  sinceMs?: number;
+  thread?: string;
+  conversation?: string;
+}
+
+interface UserRow {
+  id: number;
+  cid: number;
+  content: unknown;
+  ts: number | null;
+  thread_id: string | null;
+  tarsk_conversation_id: string | null;
+  owner: number | null;
+}
+
+interface EntryRow {
+  id: number;
+  kind: string;
+  bytes: number;
+  ts: number | null;
+  usage: string | null;
+  stop: string | null;
+  err: string | null;
+  model: string | null;
+  provider: string | null;
+  callId: string | null;
+  toolName: string | null;
+  isError: number | null;
+  text: string | null;
+  blocks: string | null;
+}
+
+interface RunBoundaries {
+  startsByConversation: Map<number, number[]>;
+  rootByUserEntry: Map<number, number>;
+}
+
+export 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;
+}
+
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1)}…`;
+}
+
+export function formatToolHistogram(tools: Map<string, number>): string {
+  return (
+    [...tools.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .map(([name, count]) => `${name}:${count}`)
+      .join(", ") || "(none)"
+  );
+}
+
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  return `${(bytes / 1024).toFixed(1)}KB`;
+}
+
+/** `24h`, `7d`, `90m`, or an ISO date/time. Returns epoch ms. */
+export function parseSince(value: string, now = Date.now()): number | undefined {
+  const match = value.match(/^(\d+)\s*([mhd])$/i);
+  if (match) {
+    return now - Number(match[1]) * DURATION_UNITS_MS[match[2].toLowerCase()];
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+/**
+ * Where Tarsk keeps `tarsk.db`. Mirrors `cli/src/core/paths.ts`:
+ * `TARSK_DATA_DIR`, else `<TARSK_APP_SUPPORT_DIR or ~/Library/Application Support/Tarsk>/data`.
+ */
+export function resolveDbPath(flag?: string): string {
+  if (flag) return resolve(flag);
+  const dataDir =
+    process.env.TARSK_DATA_DIR ??
+    join(
+      process.env.TARSK_APP_SUPPORT_DIR ??
+        join(homedir(), "Library", "Application Support", "Tarsk"),
+      "data",
+    );
+  return join(dataDir, "tarsk.db");
+}
+
+function parsePositiveInt(value: string | undefined, fallback: number): number {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+export const COMMON_USAGE_FLAGS = `Options:
+  --db <path>            tarsk.db to read (default: Tarsk data dir)
+  --since <24h|7d|ISO>   Only runs that started after this
+  --thread <threadId>    Only runs from this Tarsk thread
+  --conversation <id>    Only runs from this Tarsk conversation
+  --scan <N>             Newest N runs to load (default ${DEFAULT_SCAN})
+  --limit <N>            Runs to print (default ${DEFAULT_LIMIT})`;
+
+export function parseCommonArgs(args: string[]): CommonArgs {
+  const since = readFlagValue(args, "--since");
+  return {
+    dbPath: resolveDbPath(readFlagValue(args, "--db")),
+    scan: parsePositiveInt(readFlagValue(args, "--scan"), DEFAULT_SCAN),
+    limit: parsePositiveInt(readFlagValue(args, "--limit"), DEFAULT_LIMIT),
+    sinceMs: since ? parseSince(since) : undefined,
+    thread: readFlagValue(args, "--thread"),
+    conversation: readFlagValue(args, "--conversation"),
+  };
+}
+
+/** Open `tarsk.db` read-only. Exits with a clear message when it is missing. */
+export function openDb(dbPath: string): Database {
+  if (!existsSync(dbPath)) {
+    console.error(`No database at ${dbPath}. Pass --db <path> or set TARSK_DATA_DIR.`);
+    process.exit(1);
+  }
+  return new Database(dbPath, { readonly: true });
+}
+
+/** Tarsk prepends this wrapper to every prompt; it is noise for review. */
+const RUNTIME_CONTEXT_RE = /<runtime_context>[\s\S]*?<\/runtime_context>\s*/g;
+
+function userPromptText(content: unknown): string {
+  if (typeof content !== "string") return "";
+  let text = content;
+  if (content.startsWith("[")) {
+    try {
+      const blocks = JSON.parse(content) as Array<{ type?: string; text?: string }>;
+      text = blocks
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n");
+    } catch {
+      text = content;
+    }
+  }
+  return text.replace(RUNTIME_CONTEXT_RE, "").trim();
+}
+
+function parseJson<T>(raw: string | null): T | undefined {
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+function isoOrUndefined(ms: number | null | undefined): string | undefined {
+  return typeof ms === "number" && Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+}
+
+interface AssistantUsage {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  reasoning?: number;
+  cost?: { total?: number };
+}
+
+function createRun(user: UserRow): Run {
+  const prompt = userPromptText(user.content);
+  return {
+    entryId: user.id,
+    durableConversationId: user.cid,
+    threadId: user.thread_id ?? undefined,
+    conversationId: user.tarsk_conversation_id ?? undefined,
+    ownerConversationId: user.owner ?? undefined,
+    startedAt: isoOrUndefined(user.ts),
+    startedAtMs: user.ts ?? undefined,
+    prompt,
+    continuation: CONTINUATION_PROMPT_RE.test(prompt),
+    modelCalls: 0,
+    stopReasons: new Map(),
+    providerErrors: 0,
+    calls: [],
+    resets: 0,
+    contextTokens: [],
+    uncachedInputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    costTotal: 0,
+  };
+}
+
+function addAssistantEntry(run: Run, row: EntryRow, callsById: Map<string, ToolCall>): void {
+  run.modelCalls += 1;
+  if (row.model) run.model = row.model;
+  if (row.provider) run.provider = row.provider;
+
+  const stop = row.stop ?? "unknown";
+  run.stopReasons.set(stop, (run.stopReasons.get(stop) ?? 0) + 1);
+  if (stop === "error") run.providerErrors += 1;
+
+  const usage = parseJson<AssistantUsage>(row.usage);
+  if (usage) {
+    const input = usage.input ?? 0;
+    const cacheRead = usage.cacheRead ?? 0;
+    const cacheWrite = usage.cacheWrite ?? 0;
+    run.contextTokens.push(input + cacheRead + cacheWrite);
+    run.uncachedInputTokens += input;
+    run.cacheReadTokens += cacheRead;
+    run.cacheWriteTokens += cacheWrite;
+    run.outputTokens += usage.output ?? 0;
+    run.reasoningTokens += usage.reasoning ?? 0;
+    run.costTotal += usage.cost?.total ?? 0;
+  }
+
+  const blocks = parseJson<Array<Record<string, unknown>>>(row.blocks) ?? [];
+  for (const block of blocks) {
+    if (block.type !== "toolCall" || typeof block.name !== "string") continue;
+    const args =
+      block.arguments && typeof block.arguments === "object"
+        ? (block.arguments as Record<string, unknown>)
+        : {};
+    const call: ToolCall = {
+      id: typeof block.id === "string" ? block.id : `${row.id}:${run.calls.length}`,
+      name: block.name,
+      args,
+      signature: `${block.name}${JSON.stringify(args)}`,
+      isError: false,
+      aborted: false,
+    };
+    run.calls.push(call);
+    callsById.set(call.id, call);
+  }
+}
+
+function addToolResultEntry(row: EntryRow, callsById: Map<string, ToolCall>): void {
+  const call = row.callId ? callsById.get(row.callId) : undefined;
+  if (!call) return;
+
+  call.resultBytes = row.bytes;
+  const failed = row.isError === 1;
+  const aborted = failed && ABORTED_RE.test(row.text ?? "");
+  call.aborted = aborted;
+  call.isError = failed && !aborted;
+  if (failed) call.errorText = row.text ?? "";
+}
+
+function fillRunFromEntries(run: Run, rows: EntryRow[]): void {
+  const callsById = new Map<string, ToolCall>();
+  let lastTs = run.startedAtMs;
+
+  for (const row of rows) {
+    if (typeof row.ts === "number") lastTs = row.ts;
+    if (row.kind === "pi.assistant") addAssistantEntry(run, row, callsById);
+    else if (row.kind === "pi.tool-result") addToolResultEntry(row, callsById);
+    else if (row.kind === "pi.reset") run.resets += 1;
+  }
+
+  if (run.startedAtMs !== undefined && lastTs !== undefined && lastTs >= run.startedAtMs) {
+    run.durationSec = Math.round((lastTs - run.startedAtMs) / 1000);
+  }
+}
+
+const SELECT_ENTRY_ROWS = `
+  SELECT
+    id,
+    json_extract(record, '$.kind') AS kind,
+    length(record) AS bytes,
+    json_extract(record, '$.model[0].timestamp') AS ts,
+    json_extract(record, '$.model[0].usage') AS usage,
+    json_extract(record, '$.model[0].stopReason') AS stop,
+    json_extract(record, '$.model[0].errorMessage') AS err,
+    json_extract(record, '$.model[0].model') AS model,
+    json_extract(record, '$.model[0].provider') AS provider,
+    json_extract(record, '$.model[0].toolCallId') AS callId,
+    json_extract(record, '$.model[0].toolName') AS toolName,
+    json_extract(record, '$.model[0].isError') AS isError,
+    CASE WHEN json_extract(record, '$.kind') = 'pi.tool-result'
+      THEN substr(json_extract(record, '$.model[0].content[0].text'), 1, 1200) END AS text,
+    CASE WHEN json_extract(record, '$.kind') = 'pi.assistant'
+      THEN json_extract(record, '$.model[0].content') END AS blocks
+  FROM entries
+  WHERE conversation_id = ? AND id > ? AND id < ?
+  ORDER BY id
+`;
+
+const SELECT_USER_ROWS = `
+  SELECT
+    e.id AS id,
+    e.conversation_id AS cid,
+    json_extract(e.record, '$.model[0].content') AS content,
+    json_extract(e.record, '$.model[0].timestamp') AS ts,
+    s.thread_id AS thread_id,
+    s.conversation_id AS tarsk_conversation_id,
+    c.owner_conversation_id AS owner
+  FROM entries e
+  LEFT JOIN agent_durable_conversations a ON a.durable_conversation_id = e.conversation_id
+  LEFT JOIN agent_sessions s ON s.id = a.session_id
+  LEFT JOIN conversations c ON c.id = e.conversation_id
+  WHERE json_extract(e.record, '$.kind') = 'pi.user'
+    AND (? IS NULL OR s.thread_id = ?)
+    AND (? IS NULL OR s.conversation_id = ?)
+    AND (? IS NULL OR json_extract(e.record, '$.model[0].timestamp') >= ?)
+  ORDER BY e.id DESC
+  LIMIT ?
+`;
+
+/** Actual user prompts start runs; continuation nudges stay inside their prior run. */
+function loadRunBoundaries(db: Database, conversationIds: number[]): RunBoundaries {
+  const startsByConversation = new Map<number, number[]>();
+  const rootByUserEntry = new Map<number, number>();
+  if (conversationIds.length === 0) return { startsByConversation, rootByUserEntry };
+
+  const placeholders = conversationIds.map(() => "?").join(",");
+  const rows = db
+    .query(
+      `SELECT id, conversation_id AS cid,
+              json_extract(record, '$.model[0].content') AS content
+       FROM entries
+       WHERE conversation_id IN (${placeholders})
+         AND json_extract(record, '$.kind') = 'pi.user'
+       ORDER BY id`,
+    )
+    .all(...conversationIds) as Array<{ id: number; cid: number; content: unknown }>;
+  const latestRunByConversation = new Map<number, number>();
+
+  for (const row of rows) {
+    const prompt = userPromptText(row.content);
+    const continuation = CONTINUATION_PROMPT_RE.test(prompt);
+    const latestRun = latestRunByConversation.get(row.cid);
+
+    if (continuation && latestRun !== undefined) {
+      rootByUserEntry.set(row.id, latestRun);
+      continue;
+    }
+
+    const ids = startsByConversation.get(row.cid) ?? [];
+    ids.push(row.id);
+    startsByConversation.set(row.cid, ids);
+    rootByUserEntry.set(row.id, row.id);
+    if (!continuation) latestRunByConversation.set(row.cid, row.id);
+  }
+
+  return { startsByConversation, rootByUserEntry };
+}
+
+function nextBoundary(ids: number[] | undefined, entryId: number): number {
+  const next = ids?.find((id) => id > entryId);
+  return next ?? Number.MAX_SAFE_INTEGER;
+}
+
+function loadUserRowById(db: Database, entryId: number): UserRow | undefined {
+  return db
+    .query(
+      `SELECT
+        e.id AS id,
+        e.conversation_id AS cid,
+        json_extract(e.record, '$.model[0].content') AS content,
+        json_extract(e.record, '$.model[0].timestamp') AS ts,
+        s.thread_id AS thread_id,
+        s.conversation_id AS tarsk_conversation_id,
+        c.owner_conversation_id AS owner
+       FROM entries e
+       LEFT JOIN agent_durable_conversations a ON a.durable_conversation_id = e.conversation_id
+       LEFT JOIN agent_sessions s ON s.id = a.session_id
+       LEFT JOIN conversations c ON c.id = e.conversation_id
+       WHERE e.id = ? AND json_extract(e.record, '$.kind') = 'pi.user'`,
+    )
+    .get(entryId) as UserRow | undefined;
+}
+
+/**
+ * Load the newest runs (up to `scan`), newest first.
+ * Runs whose prompt is the automatic continuation nudge are included and flagged.
+ */
+export function loadRuns(db: Database, args: CommonArgs): Run[] {
+  const users = db
+    .query(SELECT_USER_ROWS)
+    .all(
+      args.thread ?? null,
+      args.thread ?? null,
+      args.conversation ?? null,
+      args.conversation ?? null,
+      args.sinceMs ?? null,
+      args.sinceMs ?? null,
+      args.scan,
+    ) as UserRow[];
+
+  const boundaries = loadRunBoundaries(db, [...new Set(users.map((user) => user.cid))]);
+  const selectedUsersById = new Map(users.map((user) => [user.id, user]));
+  const runStarts = new Map<number, UserRow>();
+
+  for (const user of users) {
+    const rootId = boundaries.rootByUserEntry.get(user.id) ?? user.id;
+    const root =
+      selectedUsersById.get(rootId) ?? (rootId === user.id ? user : loadUserRowById(db, rootId));
+    if (!root || (args.sinceMs !== undefined && root.ts !== null && root.ts < args.sinceMs)) {
+      continue;
+    }
+    runStarts.set(root.id, root);
+  }
+
+  const entryQuery = db.query(SELECT_ENTRY_ROWS);
+  return [...runStarts.values()]
+    .sort((a, b) => b.id - a.id)
+    .map((user) => {
+      const run = createRun(user);
+      const upper = nextBoundary(boundaries.startsByConversation.get(user.cid), user.id);
+      const rows = entryQuery.all(user.cid, user.id, upper) as EntryRow[];
+      fillRunFromEntries(run, rows);
+      return run;
+    });
+}
+
+/** Convenience for the summarizers: parse flags, open the DB, load runs, log provenance. */
+export function loadRunsFromArgs(argv: string[]): { runs: Run[]; args: CommonArgs } {
+  const args = parseCommonArgs(argv);
+  const db = openDb(args.dbPath);
+  try {
+    const runs = loadRuns(db, args);
+    console.error(`Database: ${args.dbPath}`);
+    console.error(`Runs loaded: ${runs.length} (newest first, scan=${args.scan})\n`);
+    return { runs, args };
+  } finally {
+    db.close();
+  }
+}
+
+export function isProjectConfigToolCall(call: ToolCall): boolean {
+  if (PROJECT_CONFIG_TOOLS.has(call.name)) return true;
+
+  const path = typeof call.args.path === "string" ? call.args.path : "";
+  if (path && PROJECT_CONFIG_PATH_RE.test(path)) return true;
+
+  const command = typeof call.args.command === "string" ? call.args.command : "";
+  if (command && PROJECT_CONFIG_PATH_RE.test(command)) return true;
+
+  const pattern = typeof call.args.pattern === "string" ? call.args.pattern : "";
+  return pattern === "**/SKILL.md";
+}
+
+export function toolHistogram(
+  calls: ToolCall[],
+  options: { exclProjectConfig?: boolean } = {},
+): Map<string, number> {
+  const histogram = new Map<string, number>();
+  for (const call of calls) {
+    if (options.exclProjectConfig && isProjectConfigToolCall(call)) continue;
+    histogram.set(call.name, (histogram.get(call.name) ?? 0) + 1);
+  }
+  return histogram;
+}
+
+export function failedCalls(calls: ToolCall[]): ToolCall[] {
+  return calls.filter((call) => call.isError);
+}
+
+export function abortedCallCount(calls: ToolCall[]): number {
+  return calls.filter((call) => call.aborted).length;
+}
+
+/** Cleaned tool-error text: harness wrapper tags and the `[error]` prefix removed. */
+export function failureDetail(call: ToolCall, max = 160): string {
+  const cleaned = (call.errorText ?? "failed")
+    .replace(/<\/?harness>/g, "")
+    .replace(/<\/?observation_preview[^>]*>/g, "")
+    .replace(/\[error\]\s*/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return truncate(cleaned || "failed", max);
+}
+
+/** Calls whose name+args already appeared earlier in the run (project config excluded). */
+export function repeatedCallCount(calls: ToolCall[]): number {
+  const seen = new Set<string>();
+  let repeats = 0;
+  for (const call of calls) {
+    if (isProjectConfigToolCall(call)) continue;
+    if (seen.has(call.signature)) repeats += 1;
+    seen.add(call.signature);
+  }
+  return repeats;
+}
+
+/** Calls that re-ran the exact name+args of an earlier failed call. */
+export function retriesAfterFailureCount(calls: ToolCall[]): number {
+  const failed = new Set<string>();
+  let retries = 0;
+  for (const call of calls) {
+    if (failed.has(call.signature)) retries += 1;
+    if (call.isError) failed.add(call.signature);
+  }
+  return retries;
+}
+
+export function largestResults(calls: ToolCall[], count = 3): string {
+  const sized = calls
+    .filter((call) => typeof call.resultBytes === "number" && !isProjectConfigToolCall(call))
+    .sort((a, b) => (b.resultBytes ?? 0) - (a.resultBytes ?? 0))
+    .slice(0, count);
+  return sized.map((call) => `${call.name}:${formatBytes(call.resultBytes ?? 0)}`).join(", ");
+}
+
+export function cacheReadPercent(run: Run): number | undefined {
+  const total = run.uncachedInputTokens + run.cacheReadTokens + run.cacheWriteTokens;
+  return total > 0 ? Math.round((run.cacheReadTokens / total) * 100) : undefined;
+}
+
+export function formatContextTrend(run: Run): string {
+  const tokens = run.contextTokens;
+  if (tokens.length === 0) return "n/a";
+  const peak = Math.max(...tokens);
+  return `${tokens[0]} → ${tokens[tokens.length - 1]} (peak ${peak}, ${tokens.length} calls)`;
+}
+
+export function formatStopReasons(run: Run): string {
+  return [...run.stopReasons.entries()].map(([reason, count]) => `${reason}:${count}`).join(", ");
+}
+
+/** Lines shared by every summarizer's run header. */
+export function printRunHeader(run: Run, promptMax = 120): void {
+  console.log(`- started: ${run.startedAt ?? "?"}`);
+  console.log(`- thread: ${run.threadId ?? "?"}`);
+  console.log(`- conversation: ${run.conversationId ?? "?"}`);
+  console.log(
+    `- durable conversation: ${run.durableConversationId} (entry ${run.entryId})${
+      run.ownerConversationId === undefined ? "" : ` — subagent of ${run.ownerConversationId}`
+    }`,
+  );
+  console.log(`- model: ${run.model ?? "?"}${run.provider ? ` (${run.provider})` : ""}`);
+  console.log(
+    `- prompt: ${truncate(run.prompt.replace(/\s+/g, " "), promptMax) || "?"}${
+      run.continuation ? " [auto-continue nudge]" : ""
+    }`,
+  );
+}
+
+export function printNoRunsHint(): void {
+  console.log(
+    "No agent runs found. Check --db, widen --since / --scan, or confirm an agent has run in this Tarsk data dir.",
+  );
+}