patchwork-os 1.2.0-beta.2.canary.598 → 1.2.0-beta.2.canary.600

package/dist/runStore/jsonlRunRepository.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The incumbent JSONL store, behind the ADR-0022 repository seam.
+ *
+ * This adapter holds NO logic of its own — every method forwards to
+ * `RecipeRunLog`. That is the point. It exists so the interface can be
+ * introduced with provably zero behaviour change, which is what makes the
+ * conformance suite meaningful: the suite is first pinned against the store
+ * we already trust, and only then pointed at a new one.
+ *
+ * If this file ever grows a behavioural decision, the comparison it enables
+ * stops being a comparison.
+ */
+import type { RecipeRun, RunQuery, RunStepResult } from "../runLog.js";
+import { RecipeRunLog, type RunLogOptions } from "../runLog.js";
+import type { CompleteRunInput, RunRepository, StartRunInput } from "./runRepository.js";
+export declare class JsonlRunRepository implements RunRepository {
+    private readonly log;
+    constructor(log: RecipeRunLog);
+    /** Convenience: build the adapter and the underlying log together. */
+    static open(opts: RunLogOptions): JsonlRunRepository;
+    /**
+     * Escape hatch for callers still reaching for `RecipeRunLog`-only methods
+     * (`record`, `appendDirect`, `readArchive`). Those are deliberately absent
+     * from `RunRepository` — `readArchive` in particular is a JSONL rotation
+     * detail with no meaning in a store that does not rotate by bytes.
+     *
+     * Every use of this is a migration debt marker, not an approved pattern.
+     */
+    get underlying(): RecipeRunLog;
+    startRun(input: StartRunInput): number;
+    updateRunSteps(seq: number, stepResults: RunStepResult[]): void;
+    completeRun(seq: number, input: CompleteRunInput): void;
+    query(q?: RunQuery): RecipeRun[];
+    getBySeq(seq: number): RecipeRun | null;
+    getChildSeqs(parentSeq: number): number[];
+    size(): number;
+}

package/dist/runStore/jsonlRunRepository.js

@@ -0,0 +1,56 @@
+/**
+ * The incumbent JSONL store, behind the ADR-0022 repository seam.
+ *
+ * This adapter holds NO logic of its own — every method forwards to
+ * `RecipeRunLog`. That is the point. It exists so the interface can be
+ * introduced with provably zero behaviour change, which is what makes the
+ * conformance suite meaningful: the suite is first pinned against the store
+ * we already trust, and only then pointed at a new one.
+ *
+ * If this file ever grows a behavioural decision, the comparison it enables
+ * stops being a comparison.
+ */
+import { RecipeRunLog } from "../runLog.js";
+export class JsonlRunRepository {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /** Convenience: build the adapter and the underlying log together. */
+    static open(opts) {
+        return new JsonlRunRepository(new RecipeRunLog(opts));
+    }
+    /**
+     * Escape hatch for callers still reaching for `RecipeRunLog`-only methods
+     * (`record`, `appendDirect`, `readArchive`). Those are deliberately absent
+     * from `RunRepository` — `readArchive` in particular is a JSONL rotation
+     * detail with no meaning in a store that does not rotate by bytes.
+     *
+     * Every use of this is a migration debt marker, not an approved pattern.
+     */
+    get underlying() {
+        return this.log;
+    }
+    startRun(input) {
+        return this.log.startRun(input);
+    }
+    updateRunSteps(seq, stepResults) {
+        this.log.updateRunSteps(seq, stepResults);
+    }
+    completeRun(seq, input) {
+        this.log.completeRun(seq, input);
+    }
+    query(q = {}) {
+        return this.log.query(q);
+    }
+    getBySeq(seq) {
+        return this.log.getBySeq(seq);
+    }
+    getChildSeqs(parentSeq) {
+        return this.log.getChildSeqs(parentSeq);
+    }
+    size() {
+        return this.log.size();
+    }
+}
+//# sourceMappingURL=jsonlRunRepository.js.map

package/dist/runStore/jsonlRunRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonlRunRepository.js","sourceRoot":"","sources":["../../src/runStore/jsonlRunRepository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,YAAY,EAAsB,MAAM,cAAc,CAAC;AAOhE,MAAM,OAAO,kBAAkB;IACA;IAA7B,YAA6B,GAAiB;QAAjB,QAAG,GAAH,GAAG,CAAc;IAAG,CAAC;IAElD,sEAAsE;IACtE,MAAM,CAAC,IAAI,CAAC,IAAmB;QAC7B,OAAO,IAAI,kBAAkB,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,QAAQ,CAAC,KAAoB;QAC3B,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,cAAc,CAAC,GAAW,EAAE,WAA4B;QACtD,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAC5C,CAAC;IAED,WAAW,CAAC,GAAW,EAAE,KAAuB;QAC9C,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,IAAc,EAAE;QACpB,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IAED,QAAQ,CAAC,GAAW;QAClB,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAED,YAAY,CAAC,SAAiB;QAC5B,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC1C,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;CACF"}

package/dist/runStore/runRepository.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The storage seam for run evidence — ADR-0022.
+ *
+ * WHY THIS EXISTS. `runs.jsonl` is the autonomy gate's trust evidence and also
+ * an append-only text file with no integrity properties. It failed three ways
+ * in eight weeks, each silently: #1324 (`seq` collides across instances — 142
+ * of 145 in the live log), #1340 (in-flight steps never reached disk), #1341
+ * (a concurrent reader made `completeRun` a no-op, recording a successful run
+ * as `interrupted, steps: 0`). Each was fixed; the pattern was not.
+ *
+ * This interface is the line those fixes kept crossing. It names what a run
+ * store must DO, so an implementation can be swapped without every caller
+ * learning how the bytes are laid out. `RecipeRunLog` is the incumbent
+ * implementation; a SQLite one follows, and dual-write compares them before
+ * anything flips.
+ *
+ * ## What this interface deliberately does NOT do
+ *
+ * It does not redesign what a run means. Every method mirrors a `RecipeRunLog`
+ * method with the same name and semantics, including ones that are arguably
+ * wrong (see `getBySeq`). A storage migration that also changes the domain
+ * model cannot be verified by comparing old against new, because there is no
+ * longer a fixed thing to compare — and comparison against the incumbent is
+ * the entire safety argument for the migration.
+ *
+ * Fixing those wrong-but-preserved parts happens AFTER the stores agree, not
+ * during.
+ */
+import type { RecipeRun, RunQuery, RunStepResult, RunTrigger, TerminalRunStatus } from "../runLog.js";
+/** Arguments to {@link RunRepository.startRun}. Mirrors `RecipeRunLog.startRun`. */
+export interface StartRunInput {
+    taskId: string;
+    recipeName: string;
+    trigger: RunTrigger;
+    createdAt: number;
+    startedAt?: number;
+    model?: string;
+    parentSeq?: number;
+    manualRunId?: string;
+    /** Test seam — defaults to this process. See `RecipeRun.ownerPid`. */
+    ownerPid?: number;
+}
+/** Arguments to {@link RunRepository.completeRun}. Mirrors `RecipeRunLog.completeRun`. */
+export interface CompleteRunInput {
+    status: TerminalRunStatus;
+    doneAt: number;
+    durationMs: number;
+    stepResults: RunStepResult[];
+    outputTail?: string;
+    errorMessage?: string;
+    assertionFailures?: RecipeRun["assertionFailures"];
+    inboxOutputs?: RecipeRun["inboxOutputs"];
+    budgetWarnings?: RecipeRun["budgetWarnings"];
+    tokenTotals?: RecipeRun["tokenTotals"];
+    budgetTotals?: RecipeRun["budgetTotals"];
+}
+/**
+ * A store of recipe runs and their steps.
+ *
+ * Implementations must be safe against a SECOND PROCESS writing the same
+ * store concurrently. That is not a theoretical requirement: `runs.jsonl` has
+ * eight construction sites, several of which write, and every one of the three
+ * bugs above involved two writers or a writer and a reader disagreeing.
+ */
+export interface RunRepository {
+    /**
+     * Begin a run and return its `seq`.
+     *
+     * NOTE the returned `seq` is per-instance and therefore NOT unique across
+     * processes (#1324). It is preserved because callers pass it back to
+     * `updateRunSteps` / `completeRun` within one process, where it is
+     * well-defined. Cross-process identity is `taskId`.
+     */
+    startRun(input: StartRunInput): number;
+    /** Replace the step list of an in-flight run, persisting evidence as it arrives (#1340). */
+    updateRunSteps(seq: number, stepResults: RunStepResult[]): void;
+    /** Finish a run. Must be durable before returning. */
+    completeRun(seq: number, input: CompleteRunInput): void;
+    /** Query runs, newest first. */
+    query(q?: RunQuery): RecipeRun[];
+    /**
+     * Look up one run by `seq`.
+     *
+     * PRESERVED AS-IS AND KNOWN TO BE WRONG (#1360): `seq` is not unique across
+     * processes, so this can resolve to an arbitrary colliding run. It backs the
+     * `/runs/[seq]` URL contract, so correcting it is a separate, visible change
+     * — not something to slip in behind a storage swap.
+     */
+    getBySeq(seq: number): RecipeRun | null;
+    /** `seq`s of runs whose `parentSeq` is the given run. */
+    getChildSeqs(parentSeq: number): number[];
+    /** Number of runs currently retained and readable. */
+    size(): number;
+}

package/dist/runStore/runRepository.js

@@ -0,0 +1,30 @@
+/**
+ * The storage seam for run evidence — ADR-0022.
+ *
+ * WHY THIS EXISTS. `runs.jsonl` is the autonomy gate's trust evidence and also
+ * an append-only text file with no integrity properties. It failed three ways
+ * in eight weeks, each silently: #1324 (`seq` collides across instances — 142
+ * of 145 in the live log), #1340 (in-flight steps never reached disk), #1341
+ * (a concurrent reader made `completeRun` a no-op, recording a successful run
+ * as `interrupted, steps: 0`). Each was fixed; the pattern was not.
+ *
+ * This interface is the line those fixes kept crossing. It names what a run
+ * store must DO, so an implementation can be swapped without every caller
+ * learning how the bytes are laid out. `RecipeRunLog` is the incumbent
+ * implementation; a SQLite one follows, and dual-write compares them before
+ * anything flips.
+ *
+ * ## What this interface deliberately does NOT do
+ *
+ * It does not redesign what a run means. Every method mirrors a `RecipeRunLog`
+ * method with the same name and semantics, including ones that are arguably
+ * wrong (see `getBySeq`). A storage migration that also changes the domain
+ * model cannot be verified by comparing old against new, because there is no
+ * longer a fixed thing to compare — and comparison against the incumbent is
+ * the entire safety argument for the migration.
+ *
+ * Fixing those wrong-but-preserved parts happens AFTER the stores agree, not
+ * during.
+ */
+export {};
+//# sourceMappingURL=runRepository.js.map

package/dist/runStore/runRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runRepository.js","sourceRoot":"","sources":["../../src/runStore/runRepository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchwork-os",
-  "version": "1.2.0-beta.2.canary.598",
+  "version": "1.2.0-beta.2.canary.600",
   "description": "Your personal AI runtime, local-first. Patchwork OS gives any AI model a consistent set of tools, YAML recipes, a delegation policy with approval queue, and a durable trace memory — all on your machine, all under your policy.",
   "type": "module",
   "main": "dist/index.js",