flingit 0.0.65 → 0.0.66

package/node_modules/flingflow/src/store-memory.ts

@@ -10,6 +10,7 @@ import {
   type EventStoreCheck,
   type AppendError,
   type AppendIfNoActiveError,
+  type PruneResult,
 } from "./store.js";
 
 function toError(e: unknown): Error {
@@ -375,4 +376,43 @@ export class MemoryEventStore implements EventStore {
 
     return ok(results);
   }
+
+  async pruneTerminalRunsOlderThan(cutoff: number, sim: SimulationTask): Promise<Result<PruneResult, Error>> {
+    try {
+      await sim.failpoint("store.pruneTerminalRunsOlderThan:before", cutoff);
+    } catch (e: unknown) {
+      return err(toError(e));
+    }
+
+    let result: PruneResult;
+    try {
+      let prunedRuns = 0;
+      let prunedEvents = 0;
+
+      for (const [runId, map] of this.events) {
+        if (map.size === 0) continue;
+        const maxSeq = Math.max(...map.keys());
+        const last = this.deserialize(defined(map.get(maxSeq)));
+        if (!TERMINAL_EVENT_TYPES.includes(last.event_type) || last.created_at >= cutoff) {
+          continue;
+        }
+
+        prunedRuns++;
+        prunedEvents += map.size;
+        this.events.delete(runId);
+      }
+
+      result = { prunedRuns, prunedEvents };
+    } catch (e: unknown) {
+      return err(toError(e));
+    }
+
+    try {
+      await sim.failpoint("store.pruneTerminalRunsOlderThan:after", cutoff);
+    } catch (e: unknown) {
+      return err(toError(e));
+    }
+
+    return ok(result);
+  }
 }

package/node_modules/flingflow/src/store-sqlite.ts

@@ -10,6 +10,7 @@ import {
   type EventStoreCheck,
   type AppendError,
   type AppendIfNoActiveError,
+  type PruneResult,
 } from "./store.js";
 
 function toError(e: unknown): Error {
@@ -445,6 +446,52 @@ export class SqliteEventStore implements EventStore {
     return ok(results);
   }
 
+  async pruneTerminalRunsOlderThan(cutoff: number, sim: SimulationTask): Promise<Result<PruneResult, Error>> {
+    try {
+      await sim.failpoint("store.pruneTerminalRunsOlderThan:before", cutoff);
+    } catch (e: unknown) {
+      return err(toError(e));
+    }
+
+    let result: PruneResult;
+    try {
+      const runIds = this.db.prepare(`
+        SELECT e.run_id FROM ${this.table} e
+        INNER JOIN (
+          SELECT run_id, MAX(seq) as max_seq
+          FROM ${this.table}
+          GROUP BY run_id
+        ) latest ON e.run_id = latest.run_id AND e.seq = latest.max_seq
+        WHERE e.event_type IN ('workflow_completed', 'workflow_failed')
+          AND e.created_at < ?
+      `).all(cutoff) as { run_id: string }[];
+
+      if (runIds.length === 0) {
+        result = { prunedRuns: 0, prunedEvents: 0 };
+      } else {
+        const deleteStmt = this.db.prepare(`DELETE FROM ${this.table} WHERE run_id = ?`);
+        const transaction = this.db.transaction((ids: string[]): PruneResult => {
+          let prunedEvents = 0;
+          for (const runId of ids) {
+            prunedEvents += deleteStmt.run(runId).changes;
+          }
+          return { prunedRuns: ids.length, prunedEvents };
+        });
+        result = transaction(runIds.map((row) => row.run_id));
+      }
+    } catch (e: unknown) {
+      return err(toError(e));
+    }
+
+    try {
+      await sim.failpoint("store.pruneTerminalRunsOlderThan:after", cutoff);
+    } catch (e: unknown) {
+      return err(toError(e));
+    }
+
+    return ok(result);
+  }
+
   close(): void {
     this.db.close();
   }

package/node_modules/flingflow/src/store.ts

@@ -30,6 +30,11 @@ export type EventStoreCheck = (runId: string, allEvents: WorkflowEvent[]) => voi
 export type AppendError = UniqueConstraintError | WorkflowIdMismatchError | Error;
 export type AppendIfNoActiveError = WorkflowAlreadyActiveError | UniqueConstraintError | Error;
 
+export interface PruneResult {
+  prunedRuns: number;
+  prunedEvents: number;
+}
+
 /**
  * Event payloads are stored as JSON. This means:
  * - `undefined` values in objects are silently dropped
@@ -52,4 +57,5 @@ export interface EventStore {
   getAllEvents(runId: string, sim: SimulationTask): Promise<Result<WorkflowEvent[], Error>>;
   getActiveWorkflows(sim: SimulationTask): Promise<Result<WorkflowEvent[], Error>>;
   getRecentRuns(limit: number, sim: SimulationTask): Promise<Result<WorkflowEvent[], Error>>;
+  pruneTerminalRunsOlderThan(cutoff: number, sim: SimulationTask): Promise<Result<PruneResult, Error>>;
 }

package/node_modules/flingflow/test/store-conformance.ts

@@ -326,6 +326,48 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
       expect(runIds).toContain("run-done");
     });
 
+    it("pruneTerminalRunsOlderThan removes all events for terminal runs older than the cutoff", async () => {
+      (await store.appendBatch([
+        { run_id: "run-old-done", workflow_id: "wf-old-done", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-old-done", workflow_id: "wf-old-done", seq: 1, event_type: "step_completed", payload: { step: "start", writes: {} }, created_at: 1100 },
+        { run_id: "run-old-done", workflow_id: "wf-old-done", seq: 2, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 2000 },
+      ], noSim))._unsafeUnwrap();
+
+      (await store.appendBatch([
+        { run_id: "run-old-fail", workflow_id: "wf-old-fail", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1200 },
+        { run_id: "run-old-fail", workflow_id: "wf-old-fail", seq: 1, event_type: "step_failed", payload: { step: "start", attempt: 1, reason: "boom", retryable: false }, created_at: 1300 },
+        { run_id: "run-old-fail", workflow_id: "wf-old-fail", seq: 2, event_type: "workflow_failed", payload: { reason: "boom", cause: "non_retryable" }, created_at: 2100 },
+      ], noSim))._unsafeUnwrap();
+
+      const result = (await store.pruneTerminalRunsOlderThan(3000, noSim))._unsafeUnwrap();
+      expect(result).toEqual({ prunedRuns: 2, prunedEvents: 6 });
+      expect((await store.getAllEvents("run-old-done", noSim))._unsafeUnwrap()).toEqual([]);
+      expect((await store.getAllEvents("run-old-fail", noSim))._unsafeUnwrap()).toEqual([]);
+    });
+
+    it("pruneTerminalRunsOlderThan keeps active runs and runs whose terminal event is recent", async () => {
+      (await store.appendBatch([
+        { run_id: "run-active", workflow_id: "wf-active", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-active", workflow_id: "wf-active", seq: 1, event_type: "step_started", payload: { step: "start", attempt: 1 }, created_at: 2000 },
+      ], noSim))._unsafeUnwrap();
+
+      (await store.appendBatch([
+        { run_id: "run-recent-terminal", workflow_id: "wf-recent-terminal", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 1000 },
+        { run_id: "run-recent-terminal", workflow_id: "wf-recent-terminal", seq: 1, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 4000 },
+      ], noSim))._unsafeUnwrap();
+
+      (await store.appendBatch([
+        { run_id: "run-old-created-recent-terminal", workflow_id: "wf-old-created-recent-terminal", seq: 0, event_type: "workflow_created", payload: { workflowName: "test", writes: {}, config: TEST_CONFIG }, created_at: 100 },
+        { run_id: "run-old-created-recent-terminal", workflow_id: "wf-old-created-recent-terminal", seq: 1, event_type: "workflow_completed", payload: { result: "ok" }, created_at: 4500 },
+      ], noSim))._unsafeUnwrap();
+
+      const result = (await store.pruneTerminalRunsOlderThan(3000, noSim))._unsafeUnwrap();
+      expect(result).toEqual({ prunedRuns: 0, prunedEvents: 0 });
+      expect((await store.getAllEvents("run-active", noSim))._unsafeUnwrap()).toHaveLength(2);
+      expect((await store.getAllEvents("run-recent-terminal", noSim))._unsafeUnwrap()).toHaveLength(2);
+      expect((await store.getAllEvents("run-old-created-recent-terminal", noSim))._unsafeUnwrap()).toHaveLength(2);
+    });
+
     it("rejects appending event with mismatched workflow_id for existing run_id", async () => {
       (await store.append({
         run_id: "run-1", workflow_id: "wf-1", seq: 0, event_type: "workflow_created",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "flingit",
-    "version": "0.0.65",
+    "version": "0.0.66",
     "description": "Small Software Platform - Build and deploy personal tools through conversation",
     "type": "module",
     "engines": {

package/templates/default/dot-claude/skills/fling/.hash

@@ -1 +1 @@
-3967bbd0369b234b644298e4e6435cdf
+c192df8dd0fe550a80e4c04557abd1f8

package/templates/default/dot-claude/skills/fling/SKILL.md

@@ -340,6 +340,8 @@ This gives collaborators:
 
 **IMPORTANT: Migrations MUST be idempotent** (safe to run multiple times).
 
+**IMPORTANT: Tables MUST not have more than 100 columns**: There is a hard limit on this in deployed flings, even though it will works locally. Design schemas to stay under 100 columns. Split wide tables into related tables joined by foreign keys, or move rarely-used fields into a JSON column.
+
 Use the `migrate` helper for schema changes:
 
 ```typescript