@inflexa-ai/harness 0.45.0 → 0.46.0

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,18 +78,25 @@ 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;
     /** A part of the path, with no regard to case. Each character matches only itself. */
     q?: string;
+    /** The whole path, with case. It selects the one row of that path. */
+    path?: string;
+    /**
+     * Extensions in lower case, with no dot. A row is selected when the extension of its path is a member. A row with
+     * no extension never matches, and an empty list selects each row. The read compares the members as they are.
+     */
+    extensions?: readonly string[];
     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. */
@@ -99,25 +106,47 @@ export interface ArtifactPageEntry {
     runId: string | null;
     stepId: string | null;
     createdAt: string;
-}
+};
+/** The count of the selected rows that have one extension. */
+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, and the page. The count is a separate statement because a page past the end has no row to carry it.
+ * select, grouped by extension, and the page. The count is a separate statement because a page past the end has no
+ * row to carry it. `total` is the sum of the groups.
  *
  * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included. The cost
  * 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,
         }));
@@ -179,9 +182,16 @@ export function queryAnalysisArtifacts(pool, analysisId) {
         return result.rows.map((r) => ({ path: r.path, hash: r.hash, fileType: r.file_type ?? null }));
     });
 }
+/**
+ * The extension of `path` in lower case: the text after the last dot of the file name, which is the part after the
+ * last `/`. The pattern needs one character or more before that dot and one or more after it, thus a name with no dot,
+ * a name whose only dot is its first character, and a name that ends with a dot give `NULL`.
+ */
+const EXTENSION_SQL = `lower(substring(regexp_replace(path, '^.*/', '') from '^.+\\.([^.]+)$'))`;
 /**
  * One page of the artifact ledger of an analysis, in two statements: the count of the rows that the filters
- * select, and the page. The count is a separate statement because a page past the end has no row to carry it.
+ * select, grouped by extension, and the page. The count is a separate statement because a page past the end has no
+ * row to carry it. `total` is the sum of the groups.
  *
  * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included. The cost
  * grows with the ledger of the one analysis, because the count reads each filtered row.
@@ -203,11 +213,21 @@ export function queryArtifactPage(pool, analysisId, query) {
         // `LIKE` would turn `%` and `_` of the input into wildcards.
         if (query.q !== undefined)
             conditions.push(`strpos(lower(path), lower(${bind(query.q)}::text)) > 0`);
+        if (query.path !== undefined)
+            conditions.push(`path = ${bind(query.path)}`);
+        if (query.extensions !== undefined && query.extensions.length > 0) {
+            conditions.push(`${EXTENSION_SQL} = ANY(${bind([...query.extensions])}::text[])`);
+        }
         const where = conditions.join(" AND ");
         const countResult = await pool.query({
-            text: `SELECT COUNT(*)::int AS total FROM cortex_artifacts WHERE ${where}`,
+            text: `SELECT ${EXTENSION_SQL} AS extension, COUNT(*)::int AS n
+          FROM cortex_artifacts
+          WHERE ${where}
+          GROUP BY 1
+          ORDER BY 1 ASC NULLS LAST`,
             values,
         });
+        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({
@@ -228,10 +248,29 @@ export function queryArtifactPage(pool, analysisId, query) {
                 stepId: r.source_step ?? null,
                 createdAt: r.created_at,
             })),
-            total: Number(countResult.rows[0]?.total ?? 0),
+            total: extensionCounts.reduce((sum, e) => sum + e.count, 0),
+            extensionCounts,
         };
     });
 }
+/**
+ * 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
@@ -248,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) {
@@ -269,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
@@ -282,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,
@@ -295,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,17 +8,17 @@
  */
 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, 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, queryRunsByThread, queryRunIdsByPlan, } from "./runs.js";
+setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, countRunsByAnalysis, queryRunsByThread, queryRunIdsByPlan, queryNewestPlanRun, } from "./runs.js";
 export type { InsertRunInput, RunPage, RunReservation } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";
 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,10 +7,10 @@
  * 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, queryRunsByThread, queryRunIdsByPlan, } from "./runs.js";
+setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, countRunsByAnalysis, queryRunsByThread, queryRunIdsByPlan, queryNewestPlanRun, } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";
 export { setSandboxRef, clearSandboxRef, reconcileReapedSandbox } from "./active-sandboxes.js";
 export { insertPlan, upsertPlan, loadPlan, loadPlanRecord } from "./plans.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>;

package/dist/state/init.js

@@ -7,9 +7,12 @@
  * Postgres advisory lock. A run with no pending migration runs no DDL, thus it
  * takes no lock on a Cortex table.
  */
+import { errorOf } from "../lib/thrown.js";
+import { textOf } from "../lib/unknown-text.js";
 import { Kysely, PostgresDialect, sql } from "kysely";
 import { Migrator } from "kysely/migration";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { presentFirst } from "../lib/present.js";
 import { cortexMigrations } from "./migrations/index.js";
 /**
  * The longest time that a migration statement waits for a lock. An `ALTER TABLE`
@@ -37,7 +40,7 @@ export async function initCortexState(pool, injected) {
             migrationLockTableName: "cortex_migration_lock",
             // Without a schema, the migrator finds its tables in any schema, thus a
             // test schema would see the tables of the other test schemas.
-            migrationTableSchema: rows[0].schema,
+            migrationTableSchema: presentFirst(rows, "the current schema row").schema,
         });
         const { error, results } = await migrator.migrateToLatest();
         for (const result of results ?? []) {
@@ -45,7 +48,7 @@ export async function initCortexState(pool, injected) {
                 logger.info("migration applied", { migration: result.migrationName });
         }
         if (error !== undefined) {
-            throw error instanceof Error ? error : new Error(`cortex state migration failed: ${String(error)}`);
+            throw errorOf(error) ?? new Error(`cortex state migration failed: ${textOf(error)}`);
         }
     }
     finally {

package/dist/state/migrations/20260927120000_baseline.js

@@ -6,6 +6,8 @@
  * that an earlier harness created with its boot-time DDL: it brings that
  * database to this schema, and the migrator records it.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { CompiledQuery, sql } from "kysely";
 import { backfillAiSdkMessageEnvelopes } from "../../memory/message-backfill.js";
 // No ';' may appear anywhere in this text, comments included: it is executed by
@@ -635,7 +637,7 @@ export function baseline(logger) {
                 await sql.raw("CREATE EXTENSION IF NOT EXISTS vector").execute(db);
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
+                const msg = errorMessageOf(err) ?? textOf(err);
                 throw new Error(`Cortex requires the pgvector extension. ` +
                     `CREATE EXTENSION IF NOT EXISTS vector failed: ${msg}. ` +
                     `Ask platform-infra to enable pgvector on the RDS parameter group, ` +

package/dist/state/migrations/20261026120000_add_the_edit_intents.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Record the intent of each `edit_file` call inside a durable step, keyed by
+ * the step. A rerun of the step after the write, before its checkpoint, then
+ * gives back the result of the edit and does not apply it a second time.
+ */
+import type { Migration } from "kysely/migration";
+export declare const addTheEditIntents: Migration;

package/dist/state/migrations/20261026120000_add_the_edit_intents.js

@@ -0,0 +1,21 @@
+/**
+ * Record the intent of each `edit_file` call inside a durable step, keyed by
+ * the step. A rerun of the step after the write, before its checkpoint, then
+ * gives back the result of the edit and does not apply it a second time.
+ */
+import { sql } from "kysely";
+export const addTheEditIntents = {
+    async up(db) {
+        await sql `CREATE TABLE IF NOT EXISTS cortex_edit_intents (
+  step_key     TEXT PRIMARY KEY,
+  analysis_id  TEXT NOT NULL,
+  path         TEXT NOT NULL,
+  hash_before  TEXT NOT NULL,
+  hash_after   TEXT NOT NULL,
+  result       JSONB NOT NULL,
+  call_record  JSONB NOT NULL,
+  created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+)`.execute(db);
+        await sql `CREATE INDEX IF NOT EXISTS idx_cortex_edit_intents_analysis ON cortex_edit_intents (analysis_id)`.execute(db);
+    },
+};

package/dist/state/migrations/20261027120000_record_the_applied_memory_edits.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Record the key of each `update_working_memory` call that a durable step
+ * applied, in the transaction of the edit. A rerun of the step after the edit,
+ * before its checkpoint, then finds its key and changes nothing.
+ */
+import type { Migration } from "kysely/migration";
+export declare const recordTheAppliedMemoryEdits: Migration;

package/dist/state/migrations/20261027120000_record_the_applied_memory_edits.js

@@ -0,0 +1,16 @@
+/**
+ * Record the key of each `update_working_memory` call that a durable step
+ * applied, in the transaction of the edit. A rerun of the step after the edit,
+ * before its checkpoint, then finds its key and changes nothing.
+ */
+import { sql } from "kysely";
+export const recordTheAppliedMemoryEdits = {
+    async up(db) {
+        await sql `CREATE TABLE IF NOT EXISTS cortex_applied_memory_edits (
+  call_key     TEXT PRIMARY KEY,
+  analysis_id  TEXT NOT NULL,
+  created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+)`.execute(db);
+        await sql `CREATE INDEX IF NOT EXISTS idx_cortex_applied_memory_edits_analysis ON cortex_applied_memory_edits (analysis_id)`.execute(db);
+    },
+};

package/dist/state/migrations/20261027120100_store_the_authoring_results.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Store the result of each authoring call that a durable step landed, keyed by
+ * the report thread and the step. The result lands in the transaction of the
+ * document. A rerun of the step after the landing, before its checkpoint, then
+ * gives the stored result and does not apply the operation a second time.
+ */
+import type { Migration } from "kysely/migration";
+export declare const storeTheAuthoringResults: Migration;

package/dist/state/migrations/20261027120100_store_the_authoring_results.js

@@ -0,0 +1,20 @@
+/**
+ * Store the result of each authoring call that a durable step landed, keyed by
+ * the report thread and the step. The result lands in the transaction of the
+ * document. A rerun of the step after the landing, before its checkpoint, then
+ * gives the stored result and does not apply the operation a second time.
+ */
+import { sql } from "kysely";
+export const storeTheAuthoringResults = {
+    async up(db) {
+        await sql `CREATE TABLE IF NOT EXISTS cortex_authoring_results (
+  thread_id    TEXT NOT NULL,
+  call_key     TEXT NOT NULL,
+  analysis_id  TEXT NOT NULL,
+  result       JSONB NOT NULL,
+  created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (thread_id, call_key)
+)`.execute(db);
+        await sql `CREATE INDEX IF NOT EXISTS idx_cortex_authoring_results_analysis ON cortex_authoring_results (analysis_id)`.execute(db);
+    },
+};

package/dist/state/migrations/20261027120200_key_the_groups_of_a_turn.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Key each group of a chat turn on its first row. A turn workflow writes each
+ * round in a step, and a step that runs again after its commit finds the key
+ * and stores nothing, thus no row of a turn lands two times.
+ */
+import type { Migration } from "kysely/migration";
+export declare const keyTheGroupsOfATurn: Migration;

package/dist/state/migrations/20261027120200_key_the_groups_of_a_turn.js

@@ -0,0 +1,12 @@
+/**
+ * Key each group of a chat turn on its first row. A turn workflow writes each
+ * round in a step, and a step that runs again after its commit finds the key
+ * and stores nothing, thus no row of a turn lands two times.
+ */
+import { sql } from "kysely";
+export const keyTheGroupsOfATurn = {
+    async up(db) {
+        await sql `ALTER TABLE messages ADD COLUMN IF NOT EXISTS round_key TEXT`.execute(db);
+        await sql `CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_round_key ON messages(thread_id, round_key) WHERE round_key IS NOT NULL`.execute(db);
+    },
+};

package/dist/state/migrations/20261027120300_mark_the_active_turn_of_a_thread.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mark the turn that runs on a thread. The open of a turn claims the thread,
+ * and the end of the turn releases it, thus a second turn on the same thread
+ * is refused before it writes a row.
+ */
+import type { Migration } from "kysely/migration";
+export declare const markTheActiveTurnOfAThread: Migration;

package/dist/state/migrations/20261027120300_mark_the_active_turn_of_a_thread.js

@@ -0,0 +1,11 @@
+/**
+ * Mark the turn that runs on a thread. The open of a turn claims the thread,
+ * and the end of the turn releases it, thus a second turn on the same thread
+ * is refused before it writes a row.
+ */
+import { sql } from "kysely";
+export const markTheActiveTurnOfAThread = {
+    async up(db) {
+        await sql `ALTER TABLE cortex_analysis_threads ADD COLUMN IF NOT EXISTS active_turn_id TEXT`.execute(db);
+    },
+};