@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/state/active-turns.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The turn that runs on a thread. The open of a turn claims the thread, and the
+ * end of the turn releases it. A claim whose turn no longer runs, for example
+ * after a cancel, gives way to the next turn.
+ */
+import type { ResultAsync } from "neverthrow";
+import { type DbError } from "../lib/db-result.js";
+import type { Querier } from "./db.js";
+/** The outcome of a claim: the thread is the turn's, another turn that still runs holds it, or no live thread exists. */
+export type TurnClaim = {
+    readonly kind: "claimed";
+} | {
+    readonly kind: "held";
+    readonly turnId: string;
+} | {
+    readonly kind: "no_thread";
+};
+/**
+ * Claim the thread for a turn. `stillRuns` decides if the turn that holds the thread runs. A holder that does not
+ * run gives way. Each update names the holder that it replaces, thus two opens cannot both take the thread.
+ */
+export declare function claimThreadForTurn(pool: Querier, threadId: string, turnId: string, stillRuns: (turnId: string) => Promise<boolean>): ResultAsync<TurnClaim, DbError>;
+/**
+ * Close each turn record of the thread that is still `open`, as `aborted`. A turn that a cancel ended runs no more
+ * code, thus the harness closes its record here. A record that is closed already does not change.
+ */
+export declare function closeOpenTurnRecords(pool: Querier, threadId: string): ResultAsync<void, DbError>;
+/** The turn that runs on the thread of an ask, which waits for its answer. `undefined` when no turn runs there. */
+export declare function turnOfAsk(pool: Querier, askId: string): ResultAsync<string | undefined, DbError>;
+/** The turn that holds each live thread of an analysis. A claim can outlive its turn, thus a caller checks that the turn runs. */
+export declare function queryTurnsOfAnalysis(pool: Querier, analysisId: string): ResultAsync<{
+    readonly threadId: string;
+    readonly turnId: string;
+}[], DbError>;
+/** Release the thread, when the turn still holds it. A second release changes nothing. */
+export declare function releaseThreadOfTurn(pool: Querier, threadId: string, turnId: string): ResultAsync<void, DbError>;

package/dist/state/active-turns.js

@@ -0,0 +1,67 @@
+/**
+ * The turn that runs on a thread. The open of a turn claims the thread, and the
+ * end of the turn releases it. A claim whose turn no longer runs, for example
+ * after a cancel, gives way to the next turn.
+ */
+import { z } from "zod";
+import { tryMutation, tryQuery } from "../lib/db-result.js";
+const HolderRowSchema = z.object({ active_turn_id: z.string().nullable() });
+/** Each attempt reads the holder one time. A holder that changes between two reads takes one more attempt. */
+const CLAIM_ATTEMPTS = 3;
+/**
+ * Claim the thread for a turn. `stillRuns` decides if the turn that holds the thread runs. A holder that does not
+ * run gives way. Each update names the holder that it replaces, thus two opens cannot both take the thread.
+ */
+export function claimThreadForTurn(pool, threadId, turnId, stillRuns) {
+    return tryQuery("activeTurns.claim", async () => {
+        let holder = null;
+        for (let attempt = 0; attempt < CLAIM_ATTEMPTS; attempt++) {
+            const { rows } = await pool.query("SELECT active_turn_id FROM cortex_analysis_threads WHERE thread_id = $1 AND deleted_at IS NULL", [threadId]);
+            const row = rows[0];
+            if (row === undefined)
+                return { kind: "no_thread" };
+            holder = HolderRowSchema.parse(row).active_turn_id;
+            if (holder !== null && holder !== turnId && (await stillRuns(holder)))
+                return { kind: "held", turnId: holder };
+            const taken = await pool.query(`UPDATE cortex_analysis_threads SET active_turn_id = $2
+                  WHERE thread_id = $1 AND active_turn_id IS NOT DISTINCT FROM $3`, [threadId, turnId, holder]);
+            if ((taken.rowCount ?? 0) > 0)
+                return { kind: "claimed" };
+        }
+        return { kind: "held", turnId: holder ?? "" };
+    });
+}
+/**
+ * Close each turn record of the thread that is still `open`, as `aborted`. A turn that a cancel ended runs no more
+ * code, thus the harness closes its record here. A record that is closed already does not change.
+ */
+export function closeOpenTurnRecords(pool, threadId) {
+    return tryMutation("activeTurns.closeOpen", () => pool.query("UPDATE cortex_thread_turns SET status = 'aborted', closed_at = NOW() WHERE thread_id = $1 AND status = 'open'", [threadId])).map(() => undefined);
+}
+const AskTurnRowSchema = z.object({ active_turn_id: z.string().nullable() });
+/** The turn that runs on the thread of an ask, which waits for its answer. `undefined` when no turn runs there. */
+export function turnOfAsk(pool, askId) {
+    return tryQuery("activeTurns.turnOfAsk", async () => {
+        const { rows } = await pool.query(`SELECT threads.active_turn_id FROM cortex_asks asks
+               JOIN cortex_analysis_threads threads ON threads.thread_id = asks.thread_id
+              WHERE asks.id = $1`, [askId]);
+        const row = rows[0];
+        return row === undefined ? undefined : (AskTurnRowSchema.parse(row).active_turn_id ?? undefined);
+    });
+}
+const TurnOfThreadRowSchema = z.object({ thread_id: z.string(), active_turn_id: z.string() });
+/** The turn that holds each live thread of an analysis. A claim can outlive its turn, thus a caller checks that the turn runs. */
+export function queryTurnsOfAnalysis(pool, analysisId) {
+    return tryQuery("activeTurns.ofAnalysis", async () => {
+        const { rows } = await pool.query(`SELECT thread_id, active_turn_id FROM cortex_analysis_threads
+              WHERE analysis_id = $1 AND active_turn_id IS NOT NULL AND deleted_at IS NULL`, [analysisId]);
+        return rows.map((row) => {
+            const parsed = TurnOfThreadRowSchema.parse(row);
+            return { threadId: parsed.thread_id, turnId: parsed.active_turn_id };
+        });
+    });
+}
+/** Release the thread, when the turn still holds it. A second release changes nothing. */
+export function releaseThreadOfTurn(pool, threadId, turnId) {
+    return tryMutation("activeTurns.release", () => pool.query("UPDATE cortex_analysis_threads SET active_turn_id = NULL WHERE thread_id = $1 AND active_turn_id = $2", [threadId, turnId])).map(() => undefined);
+}

package/dist/state/analyses-metrics.d.ts

@@ -10,7 +10,7 @@ import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
 import type { RunStatus, TerminalRunStatus } from "./schema.js";
 /** The newest run of one analysis, with the title of its plan and the counts of its step rows. */
-export interface LatestRunSummary {
+export type LatestRunSummary = {
     readonly analysisId: string;
     readonly runId: string;
     readonly status: RunStatus;
@@ -19,26 +19,26 @@ export interface LatestRunSummary {
     readonly totalSteps: number;
     readonly startedAt: string;
     readonly completedAt: string | null;
-}
+};
 /** A run of a list of run ids, with the fields of the newest-run read and the thread of the run. */
-export interface RunProgressSummary extends LatestRunSummary {
+export type RunProgressSummary = LatestRunSummary & {
     /** The thread of the run as the ledger stores it, or `null`. */
     readonly threadId: string | null;
-}
+};
 /** A terminal run that ended at or after a time. */
-export interface EndedRunSummary {
+export type EndedRunSummary = {
     readonly analysisId: string;
     readonly runId: string;
     readonly status: TerminalRunStatus;
     readonly completedAt: string;
-}
+};
 /** The data profile state of one analysis that has a profile status. */
-export interface DataProfileSummary {
+export type DataProfileSummary = {
     readonly analysisId: string;
     readonly status: DataProfileLifecycleStatus;
     readonly completedAt: string | null;
     readonly profiledFiles: number | null;
-}
+};
 export declare function queryRunCountsByAnalyses(pool: Querier, analysisIds: string[]): ResultAsync<Array<{
     analysisId: string;
     status: string;

package/dist/state/analyses-metrics.js

@@ -146,7 +146,7 @@ export function queryRunsEndedSince(pool, input) {
         const result = await pool.query({
             text: `SELECT analysis_id, run_id, status, completed_at
              FROM cortex_runs
-             WHERE status IN ('completed', 'partial', 'failed', 'canceled', 'suspended_insufficient_funds')
+             WHERE status IN ('completed', 'partial', 'failed', 'canceled')
                AND completed_at >= $1
              ORDER BY completed_at DESC, run_id DESC
              LIMIT $2`,
@@ -185,9 +185,9 @@ export function queryDataProfileStatusByAnalyses(pool, analysisIds) {
             status: r.data_profile_status,
             completedAt: r.data_profile_completed_at ?? null,
             profiledFiles: profileDatasetFileCount({
-                ...(r.partition === null ? {} : { partition: r.partition }),
-                ...(r.coverage === null ? {} : { coverage: r.coverage }),
-                ...(r.kinds === null ? {} : { kinds: r.kinds }),
+                partition: r.partition ?? undefined,
+                coverage: r.coverage ?? undefined,
+                kinds: r.kinds ?? undefined,
             }),
         }));
     });

package/dist/state/analyses.d.ts

@@ -19,17 +19,3 @@ export declare function loadAnalysisStatus(pool: Querier, resourceId: string): R
     status: string;
     context: string | null;
 } | null, DbError>;
-/**
- * Mark an analysis as suspended.
- * Idempotent — no-op if already suspended.
- *
- * `suspended_insufficient_funds` is the name of the one suspended state, for
- * each reason of the host, thus no reason is persisted. A chat turn never calls
- * it.
- */
-export declare function suspendAnalysis(pool: Querier, analysisId: string): ResultAsync<void, DbError>;
-/**
- * Resume a suspended analysis after the user tops up.
- * Only transitions from `suspended_insufficient_funds` → `active`.
- */
-export declare function resumeAnalysis(pool: Querier, analysisId: string): ResultAsync<void, DbError>;

package/dist/state/analyses.js

@@ -40,35 +40,3 @@ export function loadAnalysisStatus(pool, resourceId) {
         return { status: row.status, context: row.context ?? null };
     });
 }
-/**
- * Mark an analysis as suspended.
- * Idempotent — no-op if already suspended.
- *
- * `suspended_insufficient_funds` is the name of the one suspended state, for
- * each reason of the host, thus no reason is persisted. A chat turn never calls
- * it.
- */
-export function suspendAnalysis(pool, analysisId) {
-    return tryMutation("analyses.suspendAnalysis", async () => {
-        await pool.query({
-            text: `UPDATE cortex_analysis_state
-            SET status = 'suspended_insufficient_funds', updated_at = $1
-            WHERE analysis_id = $2 AND status != 'suspended_insufficient_funds'`,
-            values: [new Date().toISOString(), analysisId],
-        });
-    });
-}
-/**
- * Resume a suspended analysis after the user tops up.
- * Only transitions from `suspended_insufficient_funds` → `active`.
- */
-export function resumeAnalysis(pool, analysisId) {
-    return tryMutation("analyses.resumeAnalysis", async () => {
-        await pool.query({
-            text: `UPDATE cortex_analysis_state
-            SET status = 'active', updated_at = $1
-            WHERE analysis_id = $2 AND status = 'suspended_insufficient_funds'`,
-            values: [new Date().toISOString(), analysisId],
-        });
-    });
-}

package/dist/state/artifacts.d.ts

@@ -5,8 +5,8 @@
 import type { ResultAsync } from "neverthrow";
 import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
-import type { ArtifactRole, ArtifactRow } from "./schema.js";
-export interface RegisterArtifactInput {
+import { ArtifactRole, type ArtifactRow } from "./schema.js";
+export type RegisterArtifactInput = {
     resourceId: string;
     path: string;
     hash: string;
@@ -21,7 +21,7 @@ export interface RegisterArtifactInput {
      * `step_output` rows (their `file_id` is assigned after upload-sync).
      */
     fileId?: string | null;
-}
+};
 export declare function upsertArtifact(pool: Querier, entry: RegisterArtifactInput): ResultAsync<void, DbError>;
 /**
  * Batched upsert — writes entries in multi-row `INSERT ... VALUES` statements
@@ -34,12 +34,12 @@ export declare function upsertArtifact(pool: Querier, entry: RegisterArtifactInp
  */
 export declare function upsertArtifacts(pool: Querier, entries: RegisterArtifactInput[]): ResultAsync<void, DbError>;
 /** Result type for input artifact metadata lookups. */
-export interface InputArtifactMeta {
+export type InputArtifactMeta = {
     path: string;
     hash: string;
     size: number;
     fileId: string | null;
-}
+};
 /**
  * Query cortex_artifacts for input-role rows matching the given paths.
  * Used at the registration boundary to resolve metadata for data-source inputs.
@@ -47,11 +47,11 @@ export interface InputArtifactMeta {
 export declare function queryInputArtifacts(pool: Querier, analysisId: string, paths: string[]): ResultAsync<InputArtifactMeta[], DbError>;
 export declare function queryUnsyncedStepArtifacts(pool: Querier, resourceId: string, runId: string, stepId: string): ResultAsync<ArtifactRow[], DbError>;
 /** One registered step output, as a downstream consumer needs to name it. */
-export interface StepArtifactRef {
+export type StepArtifactRef = {
     /** Workspace-root-relative path (`runs/{runId}/{stepId}/output/de.csv`). */
     path: string;
     fileType: string | null;
-}
+};
 /**
  * The artifacts a completed step registered, most consequential first. Ordered
  * by artifact kind (outputs, then figures, notebooks, scripts, logs) and then by
@@ -60,12 +60,12 @@ export interface StepArtifactRef {
  */
 export declare function queryStepArtifactPaths(pool: Querier, resourceId: string, runId: string, stepId: string, limit: number): ResultAsync<StepArtifactRef[], DbError>;
 /** One registered artifact of an analysis, as a reader of the full artifact set names it. */
-export interface AnalysisArtifactRef {
+export type AnalysisArtifactRef = {
     /** Workspace-root-relative path (`runs/{runId}/{stepId}/output/de.csv`). */
     path: string;
     hash: string;
     fileType: string | null;
-}
+};
 /**
  * Every artifact of one analysis, ordered by path so the same call gives the same rows.
  *
@@ -78,7 +78,7 @@ export declare function queryAnalysisArtifacts(pool: Querier, analysisId: string
 /** The sort of {@link queryArtifactPage}: `path` is path order, `recent` is newest registration first. */
 export type ArtifactPageSort = "path" | "recent";
 /** The filters, the sort, and the window of {@link queryArtifactPage}. A filter that is absent selects each row. */
-export interface ArtifactPageQuery {
+export type ArtifactPageQuery = {
     runId?: string;
     stepId?: string;
     fileType?: string;
@@ -94,9 +94,9 @@ export interface ArtifactPageQuery {
     sort: ArtifactPageSort;
     limit: number;
     offset: number;
-}
+};
 /** One ledger row of {@link queryArtifactPage}. */
-export interface ArtifactPageEntry {
+export type ArtifactPageEntry = {
     /** Workspace-root-relative path (`runs/{runId}/{stepId}/output/de.csv`). */
     path: string;
     /** Bytes. */
@@ -106,20 +106,20 @@ export interface ArtifactPageEntry {
     runId: string | null;
     stepId: string | null;
     createdAt: string;
-}
+};
 /** The count of the selected rows that have one extension. */
-export interface ArtifactExtensionCount {
+export type ArtifactExtensionCount = {
     /** The extension in lower case with no dot, or `null` for the rows that have no extension. */
     extension: string | null;
     count: number;
-}
+};
 /** One page of the ledger, and the count of the rows that the filters select. */
-export interface ArtifactPage {
+export type ArtifactPage = {
     entries: ArtifactPageEntry[];
     total: number;
     /** The selected rows by extension, in the order of the extension with `null` last. The counts sum to `total`. */
     extensionCounts: ArtifactExtensionCount[];
-}
+};
 /**
  * One page of the artifact ledger of an analysis, in two statements: the count of the rows that the filters
  * select, grouped by extension, and the page. The count is a separate statement because a page past the end has no
@@ -129,11 +129,24 @@ export interface ArtifactPage {
  * grows with the ledger of the one analysis, because the count reads each filtered row.
  */
 export declare function queryArtifactPage(pool: Querier, analysisId: string, query: ArtifactPageQuery): ResultAsync<ArtifactPage, DbError>;
+/** The run and the step that wrote one path, from {@link queryArtifactOrigins}. Both are `null` for an `input` row. */
+export type ArtifactOrigin = {
+    /** Workspace-root-relative path (`runs/{runId}/{stepId}/output/de.csv`). */
+    path: string;
+    runId: string | null;
+    stepId: string | null;
+};
+/**
+ * The run and the step of each path of a list that has a ledger row of the analysis, in one statement through the key
+ * `(analysis_id, path)`. A path with no row has no entry, and the order of the entries is not defined. An empty list
+ * gives `[]` and sends no statement. The cost grows with the length of the list, thus the caller bounds it.
+ */
+export declare function queryArtifactOrigins(pool: Querier, analysisId: string, paths: readonly string[]): ResultAsync<ArtifactOrigin[], DbError>;
 /** The step-output count of one run, from {@link countArtifactsByRuns}. */
-export interface RunArtifactCount {
+export type RunArtifactCount = {
     runId: string;
     count: number;
-}
+};
 /**
  * The step-output count of each run of a list, in one statement. A run with no step output has no entry,
  * and a caller reads it as 0. An `input` row never counts. The run-completed card and a list of runs use

package/dist/state/artifacts.js

@@ -3,6 +3,8 @@
  * reconciliation.
  */
 import { tryMutation, tryQuery } from "../lib/db-result.js";
+import { presentAt } from "../lib/present.js";
+import { ArtifactRowSchema } from "./schema.js";
 export function upsertArtifact(pool, entry) {
     const now = new Date().toISOString();
     return tryMutation("artifacts.upsertArtifact", async () => {
@@ -110,6 +112,7 @@ export function queryInputArtifacts(pool, analysisId, paths) {
         return result.rows.map((r) => ({
             path: r.path,
             hash: r.hash,
+            // oxlint-disable-next-line typescript/no-unnecessary-type-conversion -- pg returns a bigint column as text; the row annotation says number, the driver gives a string, and the conversion is real.
             size: Number(r.size),
             fileId: r.file_id ?? null,
         }));
@@ -224,7 +227,7 @@ export function queryArtifactPage(pool, analysisId, query) {
           ORDER BY 1 ASC NULLS LAST`,
             values,
         });
-        const extensionCounts = countResult.rows.map((r) => ({ extension: r.extension ?? null, count: Number(r.n) }));
+        const extensionCounts = countResult.rows.map((r) => ({ extension: r.extension ?? null, count: r.n }));
         // `path` is unique in one analysis, thus it breaks each tie and two pages never overlap.
         const order = query.sort === "recent" ? "created_at DESC, path ASC" : "path ASC";
         const rowsResult = await pool.query({
@@ -250,6 +253,24 @@ export function queryArtifactPage(pool, analysisId, query) {
         };
     });
 }
+/**
+ * The run and the step of each path of a list that has a ledger row of the analysis, in one statement through the key
+ * `(analysis_id, path)`. A path with no row has no entry, and the order of the entries is not defined. An empty list
+ * gives `[]` and sends no statement. The cost grows with the length of the list, thus the caller bounds it.
+ */
+export function queryArtifactOrigins(pool, analysisId, paths) {
+    return tryQuery("artifacts.queryArtifactOrigins", async () => {
+        if (paths.length === 0)
+            return [];
+        const result = await pool.query({
+            text: `SELECT path, source_run, source_step
+          FROM cortex_artifacts
+          WHERE analysis_id = $1 AND path = ANY($2::text[])`,
+            values: [analysisId, [...paths]],
+        });
+        return result.rows.map((r) => ({ path: r.path, runId: r.source_run ?? null, stepId: r.source_step ?? null }));
+    });
+}
 /**
  * The step-output count of each run of a list, in one statement. A run with no step output has no entry,
  * and a caller reads it as 0. An `input` row never counts. The run-completed card and a list of runs use
@@ -266,7 +287,7 @@ export function countArtifactsByRuns(pool, analysisId, runIds) {
           GROUP BY source_run`,
             values: [analysisId, [...runIds]],
         });
-        return result.rows.map((r) => ({ runId: r.source_run, count: Number(r.n) }));
+        return result.rows.map((r) => ({ runId: r.source_run, count: r.n }));
     });
 }
 export function updateArtifactId(pool, resourceId, path, artifactId, fileType) {
@@ -287,8 +308,9 @@ export function updateFileIds(pool, pairs) {
         const tuples = [];
         for (let i = 0; i < pairs.length; i++) {
             const base = i * 2;
+            const pair = presentAt(pairs, i, "the artifact/file pair at the index");
             tuples.push(`($${base + 1}::text, $${base + 2}::text)`);
-            values.push(pairs[i].artifactId, pairs[i].fileId);
+            values.push(pair.artifactId, pair.fileId);
         }
         await pool.query({
             text: `UPDATE cortex_artifacts AS a
@@ -300,12 +322,13 @@ export function updateFileIds(pool, pairs) {
     });
 }
 function mapArtifactRow(row) {
-    return {
+    return ArtifactRowSchema.parse({
         resourceId: row.analysis_id,
         path: row.path,
         artifactId: row.artifact_id ?? null,
         fileId: row.file_id ?? null,
         hash: row.hash,
+        // `size` is bigint, which `pg` delivers as a string; the schema wants the number.
         size: Number(row.size),
         role: row.role,
         sourceStep: row.source_step ?? null,
@@ -313,5 +336,5 @@ function mapArtifactRow(row) {
         createdAt: row.created_at,
         unrecoverableAt: row.unrecoverable_at ?? null,
         fileType: row.file_type ?? null,
-    };
+    });
 }

package/dist/state/data-profile.d.ts

@@ -14,7 +14,7 @@ import type { Querier } from "./db.js";
  * call sites keep one import.
  */
 export type { DataProfileAxis, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileCoverage, DataProfileDimension, DataProfileFile, DataProfileGroup, DataProfileGroupSlot, DataProfileInputSignature, DataProfileKind, DataProfileMemberAnnotation, DataProfileObservation, DataProfileOrganism, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileLifecycleStatus, DataProfileResult, DataProfileSubjectSource, } from "../contracts/data-profile.js";
-export interface DataProfileStatus {
+export type DataProfileStatus = {
     status: DataProfileLifecycleStatus;
     error: string | null;
     startedAt: string | null;
@@ -28,7 +28,7 @@ export interface DataProfileStatus {
      */
     workflowId: string | null;
     seedInputFileIds: string[] | null;
-}
+};
 /**
  * Try to claim a startable row into `running`. Startable means `'pending'` (seeded,
  * not yet run) or NULL (no profile: never profiled, or cleared by `clearDataProfile`).

package/dist/state/db.d.ts

@@ -5,6 +5,16 @@
  * same operation works against the harness's connection pool or a
  * single-transaction `PoolClient`. Lifted here to keep the type declared in
  * one place instead of redeclared per file.
+ *
+ * The type is structural and states exactly what the state modules read: one
+ * `query` over the text or config form, returning `rows` and `rowCount`. A
+ * real `Pool` and `PoolClient` satisfy it, and so does a test double that
+ * answers `query` alone; nothing else of `pg`'s surface is claimed here.
  */
-import type { Pool, PoolClient } from "pg";
-export type Querier = Pool | PoolClient;
+import type { QueryConfig, QueryResultRow } from "pg";
+export type Querier = {
+    query<R extends QueryResultRow = Record<string, unknown>>(queryTextOrConfig: string | QueryConfig, values?: unknown[]): Promise<{
+        rows: R[];
+        rowCount: number | null;
+    }>;
+};

package/dist/state/db.js

@@ -5,5 +5,10 @@
  * same operation works against the harness's connection pool or a
  * single-transaction `PoolClient`. Lifted here to keep the type declared in
  * one place instead of redeclared per file.
+ *
+ * The type is structural and states exactly what the state modules read: one
+ * `query` over the text or config form, returning `rows` and `rowCount`. A
+ * real `Pool` and `PoolClient` satisfy it, and so does a test double that
+ * answers `query` alone; nothing else of `pg`'s surface is claimed here.
  */
 export {};

package/dist/state/edit-intents.d.ts

@@ -0,0 +1,4 @@
+/** The Postgres realization of the intent store of `edit_file`, over `cortex_edit_intents`. */
+import type { Querier } from "./db.js";
+import type { EditIntentStore } from "../tools/workspace/edit-file.js";
+export declare function createEditIntentStore(pool: Querier): EditIntentStore;

package/dist/state/edit-intents.js

@@ -0,0 +1,71 @@
+/** The Postgres realization of the intent store of `edit_file`, over `cortex_edit_intents`. */
+import { z } from "zod";
+import { tryMutation, tryQuery } from "../lib/db-result.js";
+import { MUTATE_TOOL_NAMES } from "../tools/workspace/mutator.js";
+const WriteRecordSchema = z.object({
+    analysisId: z.string(),
+    threadId: z.string().optional(),
+    path: z.string(),
+    hash: z.string(),
+    size: z.number(),
+    toolName: z.enum(MUTATE_TOOL_NAMES),
+    invocationId: z.string(),
+});
+const EditFileOkSchema = z.object({
+    status: z.literal("ok"),
+    path: z.string(),
+    replacements: z.number(),
+    bytesWritten: z.number(),
+    lines: z.array(z.number()).optional(),
+    decision_record_noted: z.literal(true).optional(),
+});
+const EditIntentRowSchema = z.object({
+    step_key: z.string(),
+    analysis_id: z.string(),
+    path: z.string(),
+    hash_before: z.string(),
+    hash_after: z.string(),
+    result: EditFileOkSchema,
+    call_record: z.array(WriteRecordSchema),
+});
+function toEditIntent(raw) {
+    const row = EditIntentRowSchema.parse(raw);
+    return {
+        key: row.step_key,
+        analysisId: row.analysis_id,
+        path: row.path,
+        hashBefore: row.hash_before,
+        hashAfter: row.hash_after,
+        result: row.result,
+        callRecord: row.call_record,
+    };
+}
+export function createEditIntentStore(pool) {
+    return {
+        put: (intent) => tryMutation("editIntents.put", () => pool.query(
+        // The update sets no `created_at`, thus the row keeps the time of its first put.
+        `INSERT INTO cortex_edit_intents (step_key, analysis_id, path, hash_before, hash_after, result, call_record)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (step_key) DO UPDATE SET
+           analysis_id = EXCLUDED.analysis_id,
+           path = EXCLUDED.path,
+           hash_before = EXCLUDED.hash_before,
+           hash_after = EXCLUDED.hash_after,
+           result = EXCLUDED.result,
+           call_record = EXCLUDED.call_record`, [
+            intent.key,
+            intent.analysisId,
+            intent.path,
+            intent.hashBefore,
+            intent.hashAfter,
+            JSON.stringify(intent.result),
+            JSON.stringify(intent.callRecord),
+        ])).map(() => undefined),
+        get: (key) => tryQuery("editIntents.get", async () => {
+            const { rows } = await pool.query(`SELECT step_key, analysis_id, path, hash_before, hash_after, result, call_record
+         FROM cortex_edit_intents
+         WHERE step_key = $1`, [key]);
+            return rows[0] === undefined ? null : toEditIntent(rows[0]);
+        }),
+    };
+}

package/dist/state/index.d.ts

@@ -8,9 +8,9 @@
  */
 export { initCortexState } from "./init.js";
 export type { Querier } from "./db.js";
-export { upsertAnalysis, suspendAnalysis, resumeAnalysis, loadAnalysisStatus } from "./analyses.js";
-export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifactPaths, queryUnsyncedStepArtifacts, updateArtifactId, updateFileIds, queryArtifactPage, countArtifactsByRuns, } from "./artifacts.js";
-export type { RegisterArtifactInput, InputArtifactMeta, StepArtifactRef, ArtifactExtensionCount, ArtifactPage, ArtifactPageEntry, ArtifactPageQuery, ArtifactPageSort, RunArtifactCount, } from "./artifacts.js";
+export { upsertAnalysis, loadAnalysisStatus } from "./analyses.js";
+export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifactPaths, queryUnsyncedStepArtifacts, updateArtifactId, updateFileIds, queryArtifactPage, queryArtifactOrigins, countArtifactsByRuns, } from "./artifacts.js";
+export type { RegisterArtifactInput, ArtifactOrigin, InputArtifactMeta, StepArtifactRef, ArtifactExtensionCount, ArtifactPage, ArtifactPageEntry, ArtifactPageQuery, ArtifactPageSort, RunArtifactCount, } from "./artifacts.js";
 export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, reconcileOrphanedRuns, ORPHANED_RUN_GRACE_MS, markRunCanceledIfActive, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, countRunsByAnalysis, queryRunsByThread, queryRunIdsByPlan, queryNewestPlanRun, } from "./runs.js";
 export type { InsertRunInput, RunPage, RunReservation } from "./runs.js";
@@ -18,7 +18,7 @@ export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, up
 export type { InsertStepExecutionInput, SeedStepExecutionRow, UpdateStepExecutionInput } from "./step-executions.js";
 export { setSandboxRef, clearSandboxRef, reconcileReapedSandbox } from "./active-sandboxes.js";
 export { insertPlan, upsertPlan, loadPlan, loadPlanRecord } from "./plans.js";
-export type { InsertPlanInput, UpsertPlanInput, PlanRecord } from "./plans.js";
+export type { InsertPlanInput, UpsertPlanInput, PlanRecord, PlanRowQuerier } from "./plans.js";
 export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
 export type { DataProfileStatus, DataProfileTerminalWrite, DataProfileResult, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileDimension, DataProfileGroup, DataProfileGroupSlot, DataProfileFile, DataProfileMemberAnnotation, DataProfileObservation, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileKind, DataProfileAxis, DataProfileInputSignature, DataProfileCoverage, } from "./data-profile.js";
 export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfileStatusByAnalyses, queryLatestRunsByAnalyses, queryRunProgressByRuns, queryRunsEndedSince, } from "./analyses-metrics.js";

package/dist/state/index.js

@@ -7,8 +7,8 @@
  * specific entity module (e.g. `./state/runs.js`) when narrow.
  */
 export { initCortexState } from "./init.js";
-export { upsertAnalysis, suspendAnalysis, resumeAnalysis, loadAnalysisStatus } from "./analyses.js";
-export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifactPaths, queryUnsyncedStepArtifacts, updateArtifactId, updateFileIds, queryArtifactPage, countArtifactsByRuns, } from "./artifacts.js";
+export { upsertAnalysis, loadAnalysisStatus } from "./analyses.js";
+export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifactPaths, queryUnsyncedStepArtifacts, updateArtifactId, updateFileIds, queryArtifactPage, queryArtifactOrigins, countArtifactsByRuns, } from "./artifacts.js";
 export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, reconcileOrphanedRuns, ORPHANED_RUN_GRACE_MS, markRunCanceledIfActive, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, countRunsByAnalysis, queryRunsByThread, queryRunIdsByPlan, queryNewestPlanRun, } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";

package/dist/state/init.d.ts

@@ -8,9 +8,10 @@
  * takes no lock on a Cortex table.
  */
 import type { Pool } from "pg";
+import type { Querier } from "./db.js";
 import type { Logger } from "../lib/logger.js";
 /**
  * Apply the pending migrations of the Cortex state tables. Safe to call on every
  * startup and across concurrent replicas.
  */
-export declare function initCortexState(pool: Pool, injected?: Logger): Promise<void>;
+export declare function initCortexState(pool: Querier & Pick<Pool, "connect" | "options">, injected?: Logger): Promise<void>;