@iowarp/clio-coder 0.3.8 → 0.3.9

package/dist/{chunk-FCSXB6T2.js → chunk-UOSL25KY.js}

@@ -210,6 +210,7 @@ registerEngineBuiltins();
 
 // src/engine/ai.ts
 var stream = engineStream;
+var streamSimple = engineStreamSimple;
 async function completeEngineText(input) {
   const response = await completeEngineSimple(
     input.model,
@@ -231,7 +232,17 @@ async function completeEngineText(input) {
   return {
     text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
     inputTokens: response.usage.input,
-    outputTokens: response.usage.output
+    outputTokens: response.usage.output,
+    usage: {
+      input: response.usage.input,
+      output: response.usage.output,
+      cacheRead: response.usage.cacheRead,
+      cacheWrite: response.usage.cacheWrite,
+      reasoning: response.usage.reasoning ?? 0,
+      totalTokens: response.usage.totalTokens,
+      costUsd: response.usage.cost.total
+    },
+    backend: response.backendTimings ?? null
   };
 }
 var registered = false;
@@ -325,6 +336,7 @@ export {
   activateExternalPluginApiBridge,
   StringEnum,
   stream,
+  streamSimple,
   completeEngineText,
   ensurePiAiRegistered,
   createEngineAi,
@@ -335,4 +347,4 @@ export {
   calculateEngineCost,
   registerFauxFromEnv
 };
-//# sourceMappingURL=chunk-FCSXB6T2.js.map
+//# sourceMappingURL=chunk-UOSL25KY.js.map

package/dist/{chunk-KTYTFRMB.js → chunk-VKBMFOYV.js}

@@ -9,23 +9,21 @@ import {
   isDispatchIntent,
   isToolProfileName,
   resolveDispatchPathScope
-} from "./chunk-A3WNZD3P.js";
+} from "./chunk-4H6ULJ3H.js";
 import {
   ROUTE_POLICY_VERSION,
   isRouteDecisionAgentSelection,
   isRoutingIntent,
   parseRoutingIntent
-} from "./chunk-P43ETTHK.js";
+} from "./chunk-VPTUJU4P.js";
 import {
   isExecutionRole,
   requestExecutionRole
 } from "./chunk-H7IXIC72.js";
 import {
+  AGENT_AUTOMATION_AUTHORITIES,
   pathBoundaryCovers
-} from "./chunk-TTHACPOM.js";
-import {
-  AGENT_AUTOMATION_AUTHORITIES
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-S4COXYBG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -329,14 +327,18 @@ function isRecord2(value) {
 function str(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
-function safeField(value) {
+function safeField(value, bindChangedValue = true) {
   let result = "";
   for (const character of value) {
     const code = character.codePointAt(0) ?? 0;
     result += code < 32 || code >= 127 && code <= 159 ? "?" : character;
-    if (result.length >= 256) return `${result.slice(0, 255)}\u2026`;
+    if (result.length >= 256) {
+      result = `${result.slice(0, 255)}\u2026`;
+      break;
+    }
   }
-  return result;
+  if (!bindChangedValue || result === value) return result;
+  return `${result}{sha256=${createHash("sha256").update(value, "utf8").digest("hex")}}`;
 }
 function renderLegacyPathScope(task) {
   if (task.intent !== void 0) return [];
@@ -459,7 +461,7 @@ function renderPlanText(topology, tasks, costCeilingUsd, deadlineMs, source, max
     const routing = task.routingIntent;
     const routingText = routing === void 0 ? "" : ` posture=${routing.posture} maxCostUsd=${routing.maxCostUsd ?? "none"} deadlineMs=${routing.deadlineMs ?? "none"} minimumQuality=${routing.minimumQuality ?? "none"} locality=${routing.locality}`;
     lines.push(
-      `  ${index + 1}.${role} agent=${safeField(task.agent)}${target}${model}${node}${failover}${routingText} task=${JSON.stringify(safeField(task.task))}`
+      `  ${index + 1}.${role} agent=${safeField(task.agent)}${target}${model}${node}${failover}${routingText} task_bytes=${Buffer.byteLength(task.task, "utf8")} task_sha256=${createHash("sha256").update(task.task, "utf8").digest("hex")} task_preview=${JSON.stringify(safeField(task.task, false))}`
     );
     if (task.council !== void 0) {
       lines.push(
@@ -486,22 +488,22 @@ function renderPlanText(topology, tasks, costCeilingUsd, deadlineMs, source, max
     }
     if (task.agentSelection !== null) {
       lines.push(
-        `    agent-selection=auto baseline=${safeField(task.agentSelection.baselineAgentId)} authority=${task.agentSelection.approvedAuthorities.map(safeField).join(",")} basis=${task.agentSelection.authorityBasis}`
+        `    agent-selection=auto baseline=${safeField(task.agentSelection.baselineAgentId)} authority=${task.agentSelection.approvedAuthorities.map((authority) => safeField(authority)).join(",")} basis=${task.agentSelection.authorityBasis}`
       );
     }
     if (task.stepId !== null) {
       lines.push(
-        `    step=${safeField(task.stepId)} wave=${task.wave ?? "?"} role=${task.executionRole} dependencies=${task.dependencies.map(safeField).join(",") || "none"} result=${task.expectedResultContract ?? "none"} authority=${task.authorityGrant?.requested ?? "none"} basis=${task.authorityGrant?.basis ?? "none"}`
+        `    step=${safeField(task.stepId)} wave=${task.wave ?? "?"} role=${task.executionRole} dependencies=${task.dependencies.map((dependency) => safeField(dependency)).join(",") || "none"} result=${task.expectedResultContract ?? "none"} authority=${task.authorityGrant?.requested ?? "none"} basis=${task.authorityGrant?.basis ?? "none"}`
       );
       const agentReasons = task.agentDecision?.agentSelection.evaluations.filter((evaluation) => evaluation.rejections.length > 0).slice(0, 8).map(
-        (evaluation) => `${safeField(evaluation.agentId)}:${evaluation.rejections.slice(0, 4).map(safeField).join(",")}`
+        (evaluation) => `${safeField(evaluation.agentId)}:${evaluation.rejections.slice(0, 4).map((rejection) => safeField(rejection)).join(",")}`
       );
       if (agentReasons !== void 0 && agentReasons.length > 0)
         lines.push(`    agent-exclusions=${agentReasons.join(";")}`);
     }
     if (task.briefing !== void 0) {
       lines.push(
-        `    briefing_bytes=${Buffer.byteLength(task.briefing, "utf8")} briefing_sha256=${createHash("sha256").update(task.briefing, "utf8").digest("hex")} briefing_preview=${JSON.stringify(safeField(task.briefing))}`
+        `    briefing_bytes=${Buffer.byteLength(task.briefing, "utf8")} briefing_sha256=${createHash("sha256").update(task.briefing, "utf8").digest("hex")} briefing_preview=${JSON.stringify(safeField(task.briefing, false))}`
       );
     }
     if (task.intent !== void 0) {
@@ -813,4 +815,4 @@ export {
   withResolvedDispatchPlan,
   describeDispatchPlan
 };
-//# sourceMappingURL=chunk-KTYTFRMB.js.map
+//# sourceMappingURL=chunk-VKBMFOYV.js.map

package/dist/{chunk-PT7HYKEM.js → chunk-VO2LKSTM.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   createEngineAi,
   getEngineSupportedThinkingLevels
-} from "./chunk-FCSXB6T2.js";
+} from "./chunk-UOSL25KY.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -162,4 +162,4 @@ export {
   catalogThinkingLevelsForRuntime,
   synthesizeCatalogBackedModel
 };
-//# sourceMappingURL=chunk-PT7HYKEM.js.map
+//# sourceMappingURL=chunk-VO2LKSTM.js.map

package/dist/{chunk-P43ETTHK.js → chunk-VPTUJU4P.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-H7IXIC72.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-S4COXYBG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -995,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-P43ETTHK.js.map
+//# sourceMappingURL=chunk-VPTUJU4P.js.map

package/dist/{chunk-WEH5XRJQ.js → chunk-WIE7ZOSW.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-CGKSTWHD.js";
 import {
   StringEnum
-} from "./chunk-FCSXB6T2.js";
+} from "./chunk-UOSL25KY.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -29,4 +29,4 @@ var steerToolSurface = {
 export {
   steerToolSurface
 };
-//# sourceMappingURL=chunk-WEH5XRJQ.js.map
+//# sourceMappingURL=chunk-WIE7ZOSW.js.map

package/dist/{chunk-EMYUUSFG.js → chunk-WXCJ7VME.js}

@@ -4,21 +4,21 @@ import {
   READONLY_SCOPE,
   WORKSPACE_SCOPE,
   isSubset
-} from "./chunk-VCBR6CU7.js";
+} from "./chunk-HAY4ZE2P.js";
 import {
   createLoopState,
   observe
 } from "./chunk-UOV2BYIW.js";
 import {
   createSafetyPolicyEngine
-} from "./chunk-5H3GB5BO.js";
+} from "./chunk-N3PBVRTZ.js";
 import {
   classify
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-S4COXYBG.js";
 import {
   BusChannels,
   isRunAbortedPayload
-} from "./chunk-TT36MB5S.js";
+} from "./chunk-RKRLDWD3.js";
 import {
   clioStateDir,
   stateRootRemoved
@@ -608,4 +608,4 @@ var SafetyDomainModule = {
 export {
   SafetyDomainModule
 };
-//# sourceMappingURL=chunk-EMYUUSFG.js.map
+//# sourceMappingURL=chunk-WXCJ7VME.js.map

package/dist/{chunk-4DGYLA73.js → chunk-XDOQXGFO.js}

@@ -65,11 +65,15 @@ var DEFAULT_SETTINGS = {
       everyNTools: 10,
       windowSteps: 8,
       maxTokens: 400,
-      // A memory step runs detached from the turn that triggered it, so a
-      // generous deadline costs no interactive latency. Measured steps on a
-      // small local route ranged past two minutes, and a deadline shorter than
-      // the model discards finished work as a timeout.
-      timeoutMs: 18e4
+      // A memory step runs detached from the turn that triggered it, but it
+      // runs on a real inference endpoint that the operator's own turns and
+      // dispatched workers also queue against. The operator's ledger over 14
+      // days recorded 60 llm-tier steps spending 1,666 seconds of model time
+      // for 6 injections, with one step holding a local server for 102.5
+      // seconds to answer nothing. The deadline is what a turn boundary can
+      // actually wait for; a step that runs past it is recorded as timed out
+      // rather than spending the remaining minutes unobserved.
+      timeoutMs: 3e4
     }
   },
   watchdog: { enabled: false },
@@ -155,6 +159,9 @@ var DEFAULT_SETTINGS = {
   context: {
     workingSet: DEFAULT_WORKING_SET_SETTINGS
   },
+  prewarm: {
+    enabled: true
+  },
   retry: {
     enabled: true,
     maxRetries: 3,
@@ -237,7 +244,7 @@ memory:
     everyNTools: 10
     windowSteps: 8
     maxTokens: 400
-    timeoutMs: 180000
+    timeoutMs: 30000
 
 # Opt-in turn-end watchdog. When enabled, a turn that changed the tree is
 # reviewed by one read-only verifier run briefed with the turn's coalesced diff
@@ -449,6 +456,14 @@ context:
     protectLastTurns: 6
     minEvictableTokens: 200
 
+# Prompt pre-warm. At session start, after a resume rebuilds the message array,
+# and after a compaction settles, Clio sends the prefix the next turn would send
+# (minus your text) so a local server has already prefilled it when you press
+# Enter. Local-native targets only, interactive sessions only, and never while a
+# turn or a dispatch is running.
+prewarm:
+  enabled: true
+
 # Transient provider/stream retry controls for interactive chat.
 # Retryable errors include overloads, rate limits, 5xx responses, network
 # resets, and timeouts. Context overflow uses compaction recovery instead.
@@ -497,4 +512,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-4DGYLA73.js.map
+//# sourceMappingURL=chunk-XDOQXGFO.js.map

package/dist/{chunk-JOZYP4GM.js → chunk-YKOFT37S.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   assistantTextFromEvent
-} from "./chunk-HLE42MG7.js";
+} from "./chunk-D73KXYPF.js";
 import {
   durableAssistantTextFromEvent
-} from "./chunk-TLQJPP24.js";
+} from "./chunk-TEO2TLVN.js";
 import {
   compileExecutionPlan
-} from "./chunk-J3YUBZWY.js";
+} from "./chunk-HKO36JWF.js";
 import {
   deriveExecutionRole
 } from "./chunk-H7IXIC72.js";
@@ -16,7 +16,7 @@ import {
 } from "./chunk-6XLNIQDB.js";
 import {
   BusChannels
-} from "./chunk-TT36MB5S.js";
+} from "./chunk-RKRLDWD3.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -276,4 +276,4 @@ export {
   compileScoutTransition,
   createDispatchRunEventRegistry
 };
-//# sourceMappingURL=chunk-JOZYP4GM.js.map
+//# sourceMappingURL=chunk-YKOFT37S.js.map

package/dist/chunk-YSEHGPCT.js

@@ -0,0 +1,127 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  discoverAgentRecipes
+} from "./chunk-HCBCAYZU.js";
+import {
+  assertAgentIdNamespace
+} from "./chunk-DR52UMZW.js";
+import {
+  normalizeAgentSpec
+} from "./chunk-S4COXYBG.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/agents/index.ts
+init_esm_shims();
+
+// src/domains/agents/extension.ts
+init_esm_shims();
+function createAgentsBundle(_context) {
+  let recipes = [];
+  let specs = [];
+  let diagnostics = [];
+  function discover() {
+    const nextDiagnostics = [];
+    const merged = discoverAgentRecipes(process.cwd(), nextDiagnostics);
+    const config = _context.getContract("config");
+    assertAgentIdNamespace(merged, config?.get()?.delegation?.agents ?? []);
+    recipes = merged;
+    specs = recipes.map(normalizeAgentSpec);
+    diagnostics = nextDiagnostics;
+  }
+  const extension = {
+    async start() {
+      discover();
+    },
+    async stop() {
+    }
+  };
+  const contract = {
+    list() {
+      return recipes;
+    },
+    get(id) {
+      return recipes.find((r) => r.id === id) ?? null;
+    },
+    diagnostics() {
+      return diagnostics.map((diagnostic) => ({ ...diagnostic }));
+    },
+    listSpecs() {
+      const config = _context.getContract("config");
+      const delegationAgents = config?.get()?.delegation?.agents ?? [];
+      const delegationSpecs = delegationAgents.map((agent) => ({
+        version: 1,
+        id: agent.id,
+        name: agent.id,
+        description: `External ACP delegation agent: ${agent.command} ${(agent.args ?? []).join(" ")}`,
+        source: "custom",
+        filepath: "settings.yaml",
+        tools: [],
+        toolRequirements: { required: [], optional: [] },
+        category: "explore",
+        capabilityClass: "orchestration",
+        latencyClass: "deep",
+        projectContextTier: "none",
+        audience: "custom",
+        tags: ["delegation", "acp"],
+        skills: [],
+        resultContract: { kind: "external-delegation" },
+        budget: { toolCalls: 1, readReserve: 0, synthesis: false },
+        body: "External ACP delegation."
+      }));
+      return [...specs, ...delegationSpecs];
+    },
+    getSpec(id) {
+      const found = specs.find((r) => r.id === id);
+      if (found) return found;
+      const config = _context.getContract("config");
+      const agent = config?.get()?.delegation?.agents?.find((entry) => entry.id === id);
+      if (agent) {
+        return {
+          version: 1,
+          id: agent.id,
+          name: agent.id,
+          description: `External ACP delegation agent: ${agent.command} ${(agent.args ?? []).join(" ")}`,
+          source: "custom",
+          filepath: "settings.yaml",
+          tools: [],
+          toolRequirements: { required: [], optional: [] },
+          category: "explore",
+          capabilityClass: "orchestration",
+          latencyClass: "deep",
+          projectContextTier: "none",
+          audience: "custom",
+          tags: ["delegation", "acp"],
+          skills: [],
+          resultContract: { kind: "external-delegation" },
+          budget: { toolCalls: 1, readReserve: 0, synthesis: false },
+          body: "External ACP delegation."
+        };
+      }
+      return null;
+    },
+    reload() {
+      discover();
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/agents/manifest.ts
+init_esm_shims();
+var AgentsManifest = {
+  name: "agents",
+  dependsOn: ["config"]
+};
+
+// src/domains/agents/index.ts
+var AgentsDomainModule = {
+  manifest: AgentsManifest,
+  createExtension: createAgentsBundle
+};
+
+export {
+  AgentsDomainModule
+};
+//# sourceMappingURL=chunk-YSEHGPCT.js.map

package/dist/{chunk-HFSBBKSQ.js → chunk-YW7UVM5V.js}

@@ -14,7 +14,7 @@ import {
 // src/domains/observability/trace-store.ts
 init_esm_shims();
 import { createHash } from "node:crypto";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { hostname } from "node:os";
 import { dirname, join } from "node:path";
@@ -23,6 +23,14 @@ var TRACE_DATABASE_FILE = "trace.sqlite";
 var TRACE_EVENT_POLL_LIMIT = 500;
 var TRACE_PAYLOAD_LIMIT_BYTES = 16 * 1024;
 var TRACE_WRITE_QUEUE_LIMIT = 2048;
+var TRACE_RETENTION_DAYS_ENV = "CLIO_CODER_TRACE_RETENTION_DAYS";
+var TRACE_MAX_BYTES_ENV = "CLIO_CODER_TRACE_MAX_BYTES";
+var DEFAULT_TRACE_RETENTION_POLICY = Object.freeze({
+  maxAgeDays: 30,
+  maxBytes: 128 * 1024 * 1024
+});
+var MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1e3;
+var VACUUM_RECLAIMABLE_FRACTION = 0.2;
 var sqliteConstructor = null;
 function warningTracingRequested() {
   const flagged = (argument) => argument === "--trace-warnings" || argument.startsWith("--trace-warnings=");
@@ -62,6 +70,27 @@ function databaseSyncConstructor() {
 function traceDatabasePath(stateDir) {
   return join(stateDir, TRACE_DATABASE_FILE);
 }
+function resolveTraceRetentionPolicy(overrides = {}, environment = process.env) {
+  const maxAgeDays = overrides.maxAgeDays ?? parsePositiveRetentionNumber(environment[TRACE_RETENTION_DAYS_ENV], TRACE_RETENTION_DAYS_ENV, 1);
+  const maxBytes = overrides.maxBytes ?? parsePositiveRetentionNumber(environment[TRACE_MAX_BYTES_ENV], TRACE_MAX_BYTES_ENV, 1024 * 1024);
+  return {
+    maxAgeDays: requirePositiveRetentionNumber(maxAgeDays, TRACE_RETENTION_DAYS_ENV, 1),
+    maxBytes: requirePositiveRetentionNumber(maxBytes, TRACE_MAX_BYTES_ENV, 1024 * 1024)
+  };
+}
+function parsePositiveRetentionNumber(raw, name, fallback) {
+  if (raw === void 0 || raw.trim().length === 0) {
+    return name === TRACE_RETENTION_DAYS_ENV ? DEFAULT_TRACE_RETENTION_POLICY.maxAgeDays : DEFAULT_TRACE_RETENTION_POLICY.maxBytes;
+  }
+  const value = Number(raw);
+  return requirePositiveRetentionNumber(value, name, fallback);
+}
+function requirePositiveRetentionNumber(value, name, minimum) {
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    throw new Error(`${name} must be an integer of at least ${minimum}`);
+  }
+  return value;
+}
 var TraceSchemaVersionError = class extends Error {
   constructor(found) {
     super(
@@ -221,8 +250,9 @@ function reconcileAbandonedRuns(db) {
   }
 }
 var TraceStore = class {
-  constructor(path) {
+  constructor(path, options = {}) {
     this.path = path;
+    this.retention = resolveTraceRetentionPolicy(options.retention);
     mkdirSync(dirname(path), { recursive: true });
     this.db = new (databaseSyncConstructor())(path);
     applyConnectionPragmas(this.db);
@@ -236,6 +266,7 @@ var TraceStore = class {
   }
   path;
   db;
+  retention;
   close() {
     this.db.close();
   }
@@ -249,6 +280,72 @@ var TraceStore = class {
       throw error;
     }
   }
+  /**
+   * Remove whole terminal runs, including all of their dependent rows.
+   *
+   * Age pruning runs first. If the allocated database is still above the byte
+   * limit, the oldest remaining terminal runs are removed until the live page
+   * set fits or only queued/running runs remain. A live run is never a candidate.
+   */
+  prune(policy = this.retention, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const resolved = resolveTraceRetentionPolicy(policy);
+    const nowMs = Date.parse(now);
+    if (!Number.isFinite(nowMs)) throw new Error(`trace prune time is invalid: ${now}`);
+    const bytesBefore = traceDatabaseFootprintBytes(this.path);
+    let rowsRemoved = 0;
+    let runsRemoved = 0;
+    const removed = /* @__PURE__ */ new Set();
+    const cutoff = new Date(Math.max(0, nowMs - resolved.maxAgeDays * MILLISECONDS_PER_DAY)).toISOString();
+    const ageCandidates = this.db.prepare(
+      "SELECT run_id FROM runs WHERE status IN ('success','fail') AND ended_at IS NOT NULL AND ended_at < ? ORDER BY ended_at, started_at, run_id"
+    ).all(cutoff);
+    if (ageCandidates.length > 0) {
+      this.transaction(() => {
+        for (const candidate of ageCandidates) {
+          rowsRemoved += deleteTraceRun(this.db, candidate.run_id);
+          runsRemoved += 1;
+          removed.add(candidate.run_id);
+        }
+      });
+    }
+    let pages = tracePageStats(this.db);
+    if (pages.usedBytes > resolved.maxBytes) {
+      const sizeCandidates = this.db.prepare(
+        "SELECT run_id FROM runs WHERE status IN ('success','fail') AND ended_at IS NOT NULL ORDER BY ended_at, started_at, run_id"
+      ).all();
+      this.transaction(() => {
+        for (const candidate of sizeCandidates) {
+          if (pages.usedBytes <= resolved.maxBytes) break;
+          if (removed.has(candidate.run_id)) continue;
+          rowsRemoved += deleteTraceRun(this.db, candidate.run_id);
+          runsRemoved += 1;
+          removed.add(candidate.run_id);
+          pages = tracePageStats(this.db);
+        }
+      });
+    }
+    pages = tracePageStats(this.db);
+    const reclaimableFraction = pages.pageCount === 0 ? 0 : pages.freePages / pages.pageCount;
+    const sizeNeedsReclaim = pages.allocatedBytes > resolved.maxBytes && pages.freePages > 0;
+    const vacuumed = rowsRemoved > 0 && pages.freePages > 0 && (reclaimableFraction >= VACUUM_RECLAIMABLE_FRACTION || sizeNeedsReclaim);
+    if (vacuumed) {
+      this.db.exec("VACUUM");
+      this.db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+    }
+    const protectedRuns = Number(
+      this.db.prepare("SELECT COUNT(*) AS count FROM runs WHERE status IN ('queued','running')").get().count
+    );
+    const bytesAfter = traceDatabaseFootprintBytes(this.path);
+    return {
+      runsRemoved,
+      rowsRemoved,
+      bytesBefore,
+      bytesAfter,
+      bytesRemoved: Math.max(0, bytesBefore - bytesAfter),
+      vacuumed,
+      protectedRuns
+    };
+  }
   upsertRun(input, at = (/* @__PURE__ */ new Date()).toISOString()) {
     this.transaction(() => {
       this.db.prepare(`INSERT INTO runs
@@ -533,6 +630,7 @@ var TraceStore = class {
         startedAt: at
       });
     });
+    this.prune(this.retention, at);
   }
   /**
    * Record one fact about a turn the operator ran in the chat loop.
@@ -634,8 +732,42 @@ var TraceStore = class {
         startedAt: input.at
       });
     });
+    this.prune(this.retention, input.at);
   }
 };
+function tracePageStats(db) {
+  const pageSize = Number(db.prepare("PRAGMA page_size").get().page_size);
+  const pageCount = Number(db.prepare("PRAGMA page_count").get().page_count);
+  const freePages = Number(
+    db.prepare("PRAGMA freelist_count").get().freelist_count
+  );
+  return {
+    pageCount,
+    freePages,
+    allocatedBytes: pageCount * pageSize,
+    usedBytes: Math.max(0, pageCount - freePages) * pageSize
+  };
+}
+function deleteTraceRun(db, runId) {
+  let rows = 0;
+  for (const table of ["events", "envelopes", "gate_results", "agent_sessions", "processes", "phases", "runs"]) {
+    const result = db.prepare(`DELETE FROM ${table} WHERE run_id=?`).run(runId);
+    rows += Number(result.changes);
+  }
+  return rows;
+}
+function traceDatabaseFootprintBytes(path) {
+  let total = 0;
+  for (const candidate of [path, `${path}-wal`, `${path}-shm`]) {
+    try {
+      total += statSync(candidate).size;
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+      if (code !== "ENOENT") throw error;
+    }
+  }
+  return total;
+}
 var TraceReader = class {
   constructor(path) {
     this.path = path;
@@ -991,8 +1123,11 @@ function finiteNonNegative(value) {
 
 export {
   TRACE_EVENT_POLL_LIMIT,
+  DEFAULT_TRACE_RETENTION_POLICY,
   traceDatabasePath,
+  resolveTraceRetentionPolicy,
+  TraceStore,
   TraceReader,
   createDispatchTraceMirror
 };
-//# sourceMappingURL=chunk-HFSBBKSQ.js.map
+//# sourceMappingURL=chunk-YW7UVM5V.js.map