@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/tools/lib/pathway-client.js

@@ -8,7 +8,9 @@
  * key to omit.
  */
 import { z } from "zod";
-import { apiFetch, apiFetchValidated, parseTSV } from "./api-utils.js";
+import { apiFetchText, apiFetchValidated, parseTSV } from "./api-utils.js";
+import { collapseWhitespace } from "../../lib/text.js";
+import { stripHtmlTags } from "./html-text.js";
 const KEGG_BASE = "https://rest.kegg.jp";
 // Both `reactome.org/ContentService` and `release.reactome.org/ContentService`
 // answer 200 on each path that this file calls. The two hosts serve different
@@ -17,16 +19,7 @@ const KEGG_BASE = "https://rest.kegg.jp";
 // links to stay on the primary host.
 const REACTOME_BASE = "https://release.reactome.org/ContentService";
 export function stripHtmlAndCollapseWs(s) {
-    // Strip tags to a fixpoint: a single pass can leave a `<…>` behind when
-    // removing an inner tag lets the surrounding angle brackets form a new one,
-    // so repeat until the string stops changing.
-    let out = s;
-    let prev;
-    do {
-        prev = out;
-        out = out.replace(/<[^>]+>/g, "");
-    } while (out !== prev);
-    return out.replace(/\s+/g, " ").trim();
+    return collapseWhitespace(stripHtmlTags(s));
 }
 const ORGANISM_MAP = {
     hsa: "Homo sapiens",
@@ -60,7 +53,7 @@ export const ReactomeParticipantEntitiesSchema = z.array(z.object({
     refEntities: z.array(z.object({ schemaClass: z.string().optional(), identifier: z.string().optional() })).optional(),
 }));
 export async function searchKegg(query, organism, maxResults, includeGenes) {
-    const searchRes = await apiFetch(`${KEGG_BASE}/find/pathway/${encodeURIComponent(query)}`, { parseAs: "text" });
+    const searchRes = await apiFetchText(`${KEGG_BASE}/find/pathway/${encodeURIComponent(query)}`);
     if (searchRes.isErr())
         return [];
     const rows = parseTSV(searchRes.value);
@@ -75,7 +68,7 @@ export async function searchKegg(query, organism, maxResults, includeGenes) {
     });
     if (includeGenes) {
         for (const pw of pathways) {
-            const geneRes = await apiFetch(`${KEGG_BASE}/link/${organism}/${pw.id}`, { parseAs: "text" });
+            const geneRes = await apiFetchText(`${KEGG_BASE}/link/${organism}/${pw.id}`);
             if (geneRes.isOk()) {
                 const geneRows = parseTSV(geneRes.value);
                 pw.genes = geneRows.map((r) => (r[1] ?? "").replace(`${organism}:`, ""));
@@ -125,13 +118,13 @@ export function parseKeggPathwayLinks(rows) {
  * organism, thus it replaces one `get/{id}` call for each membership.
  */
 export async function keggPathwaysForGene(geneSymbol, organism, maxResults) {
-    const geneRes = await apiFetch(`${KEGG_BASE}/find/${organism}/${encodeURIComponent(geneSymbol)}`, { parseAs: "text" });
+    const geneRes = await apiFetchText(`${KEGG_BASE}/find/${organism}/${encodeURIComponent(geneSymbol)}`);
     if (geneRes.isErr())
         return [];
     const geneId = selectKeggGeneId(parseTSV(geneRes.value), geneSymbol);
     if (!geneId)
         return [];
-    const linkRes = await apiFetch(`${KEGG_BASE}/link/pathway/${encodeURIComponent(geneId)}`, { parseAs: "text" });
+    const linkRes = await apiFetchText(`${KEGG_BASE}/link/pathway/${encodeURIComponent(geneId)}`);
     if (linkRes.isErr())
         return [];
     const pathwayIds = parseKeggPathwayLinks(parseTSV(linkRes.value)).slice(0, maxResults);
@@ -148,7 +141,7 @@ export async function keggPathwaysForGene(geneSymbol, organism, maxResults) {
 /** The pathway vocabulary of one organism, keyed by the pathway identifier. */
 async function keggPathwayNames(organism) {
     const names = new Map();
-    const res = await apiFetch(`${KEGG_BASE}/list/pathway/${encodeURIComponent(organism)}`, { parseAs: "text" });
+    const res = await apiFetchText(`${KEGG_BASE}/list/pathway/${encodeURIComponent(organism)}`);
     if (res.isErr())
         return names;
     for (const cols of parseTSV(res.value)) {
@@ -217,16 +210,19 @@ export async function searchPathways(query, options = {}) {
     return results.flat();
 }
 /** A Reactome stable identifier, for example `R-HSA-109581`. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the Reactome stable-id grammar: R-, three letters, digits, and an optional dotted subnumber.
 const REACTOME_ID_RE = /^R-[A-Z]{3}-\d+(\.\d+)?$/;
 /** A KEGG pathway identifier, for example `hsa04010` or `map04010`. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the KEGG pathway-id grammar: three or four lowercase organism letters plus five digits.
 const KEGG_ID_RE = /^[a-z]{3,4}\d{5}$/;
 /** Read one field out of a KEGG flat-file record. */
 function keggField(record, field) {
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the field name is a caller literal ("NAME", "DESCRIPTION"); the anchored multiline form reads the KEGG flat-file grammar.
     const match = new RegExp(`^${field}\\s+(.*)$`, "m").exec(record);
     return match?.[1]?.trim() || null;
 }
 async function getKeggPathway(id) {
-    const res = await apiFetch(`${KEGG_BASE}/get/${encodeURIComponent(id)}`, { parseAs: "text" });
+    const res = await apiFetchText(`${KEGG_BASE}/get/${encodeURIComponent(id)}`);
     if (res.isErr())
         return null;
     const record = res.value;
@@ -238,7 +234,7 @@ async function getKeggPathway(id) {
         id,
         name,
         source: "kegg",
-        ...(description ? { description } : {}),
+        description: description ?? undefined,
         url: `https://www.kegg.jp/pathway/${id}`,
     };
 }
@@ -255,7 +251,7 @@ async function getReactomePathway(id) {
         id: stId,
         name: stripHtmlAndCollapseWs(entry.displayName ?? ""),
         source: "reactome",
-        ...(description ? { description: stripHtmlAndCollapseWs(description) } : {}),
+        description: description === undefined ? undefined : stripHtmlAndCollapseWs(description),
         url: `https://reactome.org/content/detail/${stId}`,
     };
 }

package/dist/tools/lib/pharmgkb-client.d.ts

@@ -45,11 +45,11 @@ export declare const PharmgkbResponseSchema: z.ZodObject<{
  * phenotype, guideline source and summary live on other PharmGKB resources, so
  * they are absent here rather than present-and-null.
  */
-export interface PharmgkbAnnotation {
+export type PharmgkbAnnotation = {
     gene: string;
     drug: string;
     levelOfEvidence: string;
-}
+};
 export declare function searchPharmgkb(query: string, searchType: "gene" | "drug", limit?: number): Promise<{
     annotations: PharmgkbAnnotation[];
     totalFound: number;

package/dist/tools/lib/pharmgkb-client.js

@@ -38,7 +38,7 @@ export async function searchPharmgkb(query, searchType, limit = 20) {
             return { annotations: [], totalFound: 0 };
         throw new Error(describeApiError(res.error));
     }
-    const data = res.value?.data ?? [];
+    const data = res.value.data ?? [];
     const annotations = data.slice(0, limit).map((ann) => ({
         gene: ann.location?.genes?.map((g) => g.symbol).join(", ") ?? query,
         drug: ann.relatedChemicals?.map((c) => c.name).join(", ") ?? "",

package/dist/tools/lib/protein-family-modality.d.ts

@@ -2,12 +2,12 @@
  * Protein-family → preferred modality lookup, used by §2.2 Tractability
  * fallback when Open Targets has no tractability assessment for the target.
  */
-export interface ModalityFallback {
+export type ModalityFallback = {
     family: string | null;
     preferred_modality: string;
     rationale: string;
     source: "family-match" | "default";
-}
+};
 /**
  * Infer a preferred modality from a free-text protein-family description
  * (typically the UniProt family/keyword). Returns the dataset default when

package/dist/tools/lib/protein-family-modality.js

@@ -4,8 +4,6 @@
  */
 import familyMappingData from "../../data/protein-family-modality.json" with { type: "json" };
 import { normalizeProteinFamily } from "./protein-family-normalize.js";
-// The JSON import yields an untyped/structurally-wide value; cast to the declared
-// shape, which the bundled data file is authored to satisfy.
 const dataset = familyMappingData;
 function loadDataset() {
     return dataset;

package/dist/tools/lib/protein-family-normalize.js

@@ -11,19 +11,26 @@ const FAMILIES = [
     {
         canonical: "g protein-coupled receptor",
         patterns: [
+            // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the hyphen-variant spellings of the GPCR name, matched as whole words.
             /\bg[-\s]?protein[-\s]?coupled\s+receptor\b/i,
+            // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the GPCR abbreviation as a whole word.
             /\bgpcr\b/i,
+            // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the seven-transmembrane spelling of the family name.
             /\b7tm\s+receptor\b/i,
+            // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the rhodopsin-like subfamily spelling.
             /\brhodopsin-like\s+receptor\b/i,
+            // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the secretin-like subfamily spelling.
             /\bsecretin-like\s+receptor\b/i,
         ],
     },
     {
         canonical: "serine/threonine-protein kinase",
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the hyphen-variant spellings of the serine/threonine kinase name.
         patterns: [/\bserine\/threonine[-\s]?protein\s+kinase\b/i],
     },
     {
         canonical: "tyrosine-protein kinase",
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the hyphen-variant spellings of the tyrosine kinase name.
         patterns: [/\btyrosine[-\s]?protein\s+kinase\b/i],
     },
     // Extend as additional hyphen-style mismatches surface. The default branch

package/dist/tools/lib/pubchem-client.d.ts

@@ -13,14 +13,14 @@
  * carries `.optional()`, not `.nullable()`.
  */
 import { z } from "zod";
-export interface PubChemCompoundProperties {
+export type PubChemCompoundProperties = {
     cid: number;
     molecularWeight: number | null;
     inchiKey: string | null;
     canonicalSmiles: string | null;
     hBondDonorCount: number | null;
     hBondAcceptorCount: number | null;
-}
+};
 export declare const PubChemPropertyResponseSchema: z.ZodObject<{
     PropertyTable: z.ZodOptional<z.ZodObject<{
         Properties: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/tools/lib/pubchem-client.js

@@ -100,6 +100,7 @@ export async function getCompoundPropertiesByInChIKey(inchiKey) {
         return null;
     return getCompoundPropertiesByCID(cid);
 }
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the amide-bond motif C(=O)N read out of a SMILES string; the literal atoms are the chemistry.
 const AMIDE_BOND_RE = /C\(=O\)N/g;
 /**
  * Heuristic molecule-type classifier driven by PubChem properties.

package/dist/tools/lib/pubchem-ops.d.ts

@@ -102,11 +102,11 @@ export declare const PubChemPropertyResponseSchema: z.ZodObject<{
         }>>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export interface PubChemCrossRef {
+export type PubChemCrossRef = {
     /** The registry that the identifier pattern names, or `null` when no pattern matches. */
     source: string | null;
     id: string;
-}
+};
 export declare const PubChemXrefResponseSchema: z.ZodObject<{
     InformationList: z.ZodOptional<z.ZodObject<{
         Information: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -117,13 +117,13 @@ export declare const PubChemXrefResponseSchema: z.ZodObject<{
 }, z.core.$strip>;
 /** The registry of one identifier, or `null` when no pattern matches it. */
 export declare function classifyRegistryId(id: string): string | null;
-export interface PubChemAssay {
+export type PubChemAssay = {
     aid: number;
     assayName: string | null;
     targetName: string | null;
     activityOutcome: string | null;
     activityValue: number | null;
-}
+};
 export declare const PugAssaySummarySchema: z.ZodObject<{
     Table: z.ZodOptional<z.ZodObject<{
         Columns: z.ZodOptional<z.ZodObject<{

package/dist/tools/lib/pubchem-ops.js

@@ -95,18 +95,26 @@ export const PubChemXrefResponseSchema = z.object({
  * A loose pattern runs last, thus a specific registry claims its own id first.
  */
 const REGISTRY_PATTERNS = [
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the ChEMBL id format: the CHEMBL prefix plus digits.
     ["ChEMBL", /^CHEMBL\d+$/],
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the ChEBI id format: the CHEBI: prefix plus digits.
     ["ChEBI", /^CHEBI:\d+$/],
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the DrugBank id format: the DB prefix plus five digits.
     ["DrugBank", /^DB\d{5}$/],
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the KEGG id format: one C or D compound letter plus five digits.
     ["KEGG", /^[CD]\d{5}$/],
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the HMDB id format: the HMDB prefix plus digits.
     ["HMDB", /^HMDB\d+$/],
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the CAS registry format: two to seven digits, a dash pair, and one check digit.
     ["CAS", /^\d{2,7}-\d{2}-\d$/],
     // A PDB id is four characters that start with a digit. The lookahead demands a
     // letter as well, thus a plain registry number does not read as a structure.
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the PDB id format: a digit, then three alphanumerics, with the lookahead that demands a letter among them.
     ["PDB", /^[1-9](?=.*[A-Za-z])[0-9A-Za-z]{3}$/],
     // A UNII is ten alphanumeric characters, and the lookahead demands a letter
     // among them. A plain ten-digit registry number, such as `0000050782`, matches
     // the pattern without it, and the row then names the wrong registry.
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the UNII format: ten uppercase alphanumerics, with the lookahead that demands a letter among them.
     ["UNII", /^(?=.*[A-Z])[A-Z0-9]{10}$/],
 ];
 /** The registry of one identifier, or `null` when no pattern matches it. */

package/dist/tools/lib/pubmed-client.d.ts

@@ -9,29 +9,29 @@
  * `.optional()`, not `.nullable()`.
  */
 import { type ArticleDetail, type ArticleSection, type FullTextResult, type PubmedSearchOptions, type PubMedSummary } from "../../literature/sources/pubmed.js";
-export type { PubMedSummary, ArticleDetail, ArticleSection, FullTextResult };
+export type { PubMedSummary, ArticleDetail, ArticleSection, FullTextResult } from "../../literature/sources/pubmed.js";
 export type SearchOptions = PubmedSearchOptions;
 /** PubMed search via esearch + esummary. */
 export declare function searchPubmed(ncbiApiKey: string | undefined, query: string, options?: SearchOptions, signal?: AbortSignal): Promise<{
     totalFound: number;
     results: PubMedSummary[];
 }>;
-export interface DetailOptions {
+export type DetailOptions = {
     /** Authors kept per article before collapsing the rest into `authorCount`. */
     maxAuthors?: number;
     /** MeSH terms kept per article; 0 drops the list entirely. */
     maxMeshTerms?: number;
-}
+};
 /**
  * One article as the tool returns it: `ArticleDetail` with the two unbounded
  * list fields trimmed. A consortium paper can carry hundreds of authors and
  * dozens of MeSH headings — neither is worth the context, so the counts travel
  * instead of the tails.
  */
-export interface BoundedArticleDetail extends ArticleDetail {
+export type BoundedArticleDetail = ArticleDetail & {
     authorCount: number;
     meshTermCount: number;
-}
+};
 /** Fetch full PubMed article details (efetch + ID Converter for PMC). */
 export declare function getArticleDetails(ncbiApiKey: string | undefined, pmids: string[], signal?: AbortSignal): Promise<{
     articles: ArticleDetail[];
@@ -39,19 +39,19 @@ export declare function getArticleDetails(ncbiApiKey: string | undefined, pmids:
 }>;
 /** Trim the two unbounded list fields on each article, recording their true sizes. */
 export declare function boundArticleDetails(articles: ArticleDetail[], options?: DetailOptions): BoundedArticleDetail[];
-export interface FullTextOptions {
+export type FullTextOptions = {
     /** Case-insensitive substring match against section headings. */
     sections?: string[];
     /** Character budget across the returned section bodies. */
     maxChars?: number;
-}
+};
 /**
  * A full text trimmed to a character budget. `outline` always lists EVERY
  * section in the article with its size and whether the body came back, so one
  * call is enough to decide which sections a follow-up should request — the
  * alternative is the agent guessing headings it has not seen.
  */
-export interface BoundedFullText {
+export type BoundedFullText = {
     fullText: string;
     sections: ArticleSection[];
     outline: {
@@ -62,7 +62,7 @@ export interface BoundedFullText {
     totalChars: number;
     returnedChars: number;
     truncated: boolean;
-}
+};
 /**
  * Fetch open-access full text from PMC, trimmed to a section filter and a
  * character budget. Returns null when the article is not open-access.

package/dist/tools/lib/pubmed-client.js

@@ -11,7 +11,7 @@
 import { createPubmedSource, } from "../../literature/sources/pubmed.js";
 function pubmedSource(ncbiApiKey) {
     return createPubmedSource({
-        ...(ncbiApiKey === undefined ? {} : { apiKey: ncbiApiKey }),
+        apiKey: ncbiApiKey,
         maxRetries: 3,
         retryDelayMs: 1_000,
         timeoutMs: 90_000,

package/dist/tools/lib/string-client.d.ts

@@ -8,15 +8,15 @@
  * `.nullable()`.
  */
 import { z } from "zod";
-export interface StringInteraction {
+export type StringInteraction = {
     proteinA: string;
     proteinB: string;
     score: number;
     experimentalScore?: number;
     databaseScore?: number;
     textminingScore?: number;
-}
-export interface StringEnrichment {
+};
+export type StringEnrichment = {
     category: string;
     term: string;
     description: string;
@@ -24,12 +24,12 @@ export interface StringEnrichment {
     fdr: number;
     geneCount: number;
     genes: string[];
-}
-export interface InteractionOptions {
+};
+export type InteractionOptions = {
     species?: number;
     minScore?: number;
     limit?: number;
-}
+};
 export declare const StringInteractionSchema: z.ZodPipe<z.ZodObject<{
     preferredName_A: z.ZodOptional<z.ZodString>;
     preferredName_B: z.ZodOptional<z.ZodString>;

package/dist/tools/lib/uniprot-client.d.ts

@@ -7,14 +7,14 @@
  * carries `.optional()`, not `.nullable()`.
  */
 import { z } from "zod";
-export interface UniProtRecord {
+export type UniProtRecord = {
     primaryAccession: string;
     uniProtkbId: string | null;
     geneNames: string[];
     chemblIds: string[];
     reactomePathwayIds: string[];
     proteinFamilyText: string | null;
-}
+};
 /**
  * Fetch a single UniProtKB entry by accession. Returns null on 404; throws
  * on other HTTP errors so callers can surface upstream outages.
@@ -25,7 +25,7 @@ export declare function getChemblIdsByUniProt(accession: string): Promise<string
 /** All Reactome pathway ids cross-referenced from a UniProt accession. */
 export declare function getReactomePathwaysByUniProt(accession: string): Promise<string[]>;
 /** One protein of a UniProtKB search. */
-export interface UniProtProtein {
+export type UniProtProtein = {
     accession: string;
     /** The UniProtKB ID, for example `BRCA1_HUMAN`. */
     uniProtkbId: string | null;
@@ -38,7 +38,7 @@ export interface UniProtProtein {
     subcellularLocations: string[];
     /** True for a Swiss-Prot entry, false for a TrEMBL entry. */
     reviewed: boolean;
-}
+};
 /**
  * One result row of `uniprotkb/search`, with the same all-optional discipline as
  * `UniProtRecordSchema`: UniProt omits the key of an absent value, thus every
@@ -131,19 +131,19 @@ export declare const UniProtSearchResponseSchema: z.ZodObject<{
  * never reach one, because the 400 fails the whole request.
  */
 export declare function isUniProtAccession(query: string): boolean;
-export interface SearchProteinsOptions {
+export type SearchProteinsOptions = {
     /** NCBI taxonomy id; omit to search every organism. */
     organismId?: number;
     /** Swiss-Prot only when true (the default), Swiss-Prot and TrEMBL when false. */
     reviewedOnly?: boolean;
     /** Max rows returned. */
     limit?: number;
-}
-export interface SearchProteinsResult {
+};
+export type SearchProteinsResult = {
     proteins: UniProtProtein[];
     /** True when UniProt held at least one row beyond `limit`. */
     hasMore: boolean;
-}
+};
 /**
  * Search UniProtKB for a protein by gene symbol or by accession.
  *

package/dist/tools/lib/uniprot-client.js

@@ -206,7 +206,10 @@ function toProtein(raw) {
         accession: raw.primaryAccession ?? "",
         uniProtkbId: raw.uniProtkbId ?? null,
         proteinName: extractProteinName(raw),
-        geneNames: (raw.genes ?? []).map((gene) => gene.geneName?.value).filter((name) => Boolean(name)),
+        geneNames: (raw.genes ?? []).flatMap((gene) => {
+            const name = gene.geneName?.value;
+            return name ? [name] : [];
+        }),
         sequenceLength: raw.sequence?.length ?? null,
         function: extractFunctionText(raw),
         subcellularLocations: extractSubcellularLocations(raw),
@@ -222,6 +225,7 @@ function toProtein(raw) {
  * that match this form. Thus the match decides only whether the `accession:`
  * clause is SAFE to send, never which space the query names.
  */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the full UniProt accession grammar, both entry-class arms with the optional isoform suffix; the shape overlap with gene symbols is why the match decides safety only.
 const ACCESSION_RE = /^(?:[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9](?:[A-Z][A-Z0-9]{2}[0-9]){1,2})(?:-\d+)?$/i;
 /**
  * Can the query ride in an `accession:` clause?

package/dist/tools/memory/update-working-memory.d.ts

@@ -23,41 +23,44 @@
  * exists AND belongs to this analysis (`cortex_runs.analysis_id`) before it is
  * stored: an unknown runId is an `err(ToolError)` the model can correct from,
  * not a silent reference to a run that never existed.
+ *
+ * Inside a durable step, the store records the key of the step in the
+ * transaction of the edit. A rerun of the step after the edit, before its
+ * checkpoint, then changes nothing and gives ok.
  */
 import type { Pool } from "pg";
 import { z } from "zod";
 import type { WorkingMemoryStore } from "../../memory/working-memory.js";
+import { type Tool } from "../define-tool.js";
 declare const inputSchema: z.ZodObject<{
     section: z.ZodEnum<{
         constraint: "constraint";
+        finding: "finding";
         goal: "goal";
         hypothesis: "hypothesis";
-        finding: "finding";
     }>;
     operation: z.ZodOptional<z.ZodEnum<{
         add: "add";
-        revise: "revise";
         retire: "retire";
+        revise: "revise";
     }>>;
     text: z.ZodOptional<z.ZodString>;
     id: z.ZodOptional<z.ZodString>;
     origin: z.ZodOptional<z.ZodEnum<{
-        user: "user";
         agent: "agent";
+        user: "user";
     }>>;
     runId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type Input = z.infer<typeof inputSchema>;
-interface UpdateOutput {
+type UpdateOutput = {
     readonly ok: true;
     readonly section: Input["section"];
-}
-export declare function createUpdateWorkingMemoryTool(workingMemory: WorkingMemoryStore, pool: Pool): import("../define-tool.js").Tool<{
-    section: "constraint" | "goal" | "hypothesis" | "finding";
-    operation?: "add" | "revise" | "retire" | undefined;
-    text?: string | undefined;
-    id?: string | undefined;
-    origin?: "user" | "agent" | undefined;
-    runId?: string | undefined;
-}, UpdateOutput>;
+};
+export type UpdateWorkingMemoryOpts = {
+    /** The key of the durable step that runs the call, `undefined` outside one. */
+    readonly stepKey: () => string | undefined;
+};
+export declare const DEFAULT_UPDATE_WORKING_MEMORY_OPTS: UpdateWorkingMemoryOpts;
+export declare function createUpdateWorkingMemoryTool(workingMemory: WorkingMemoryStore, pool: Pool, opts?: UpdateWorkingMemoryOpts): Tool<z.infer<typeof inputSchema>, UpdateOutput>;
 export {};

package/dist/tools/memory/update-working-memory.js

@@ -23,6 +23,10 @@
  * exists AND belongs to this analysis (`cortex_runs.analysis_id`) before it is
  * stored: an unknown runId is an `err(ToolError)` the model can correct from,
  * not a silent reference to a run that never existed.
+ *
+ * Inside a durable step, the store records the key of the step in the
+ * transaction of the edit. A rerun of the step after the edit, before its
+ * checkpoint, then changes nothing and gives ok.
  */
 import { err, ok } from "neverthrow";
 import { z } from "zod";
@@ -31,6 +35,7 @@ import { toThrowable, unwrapOrThrow } from "../../lib/result.js";
 import { isWorkingMemoryRejection, WORKING_MEMORY_LIMITS } from "../../memory/working-memory.js";
 import { queryRun } from "../../state/index.js";
 import { defineTool } from "../define-tool.js";
+import { durableStepKey } from "../workspace/edit-file.js";
 const { goalChars, entryChars, constraints, hypotheses, findings } = WORKING_MEMORY_LIMITS;
 const inputSchema = z
     .object({
@@ -91,10 +96,16 @@ const inputSchema = z
 function toListOp(input) {
     switch (input.operation ?? "add") {
         case "add":
+            if (input.text === undefined)
+                throw new Error("add requires text");
             return { op: "add", text: input.text };
         case "revise":
+            if (input.id === undefined || input.text === undefined)
+                throw new Error("revise requires id and text");
             return { op: "revise", id: input.id, text: input.text };
         case "retire":
+            if (input.id === undefined)
+                throw new Error("retire requires id");
             return { op: "retire", id: input.id };
     }
 }
@@ -105,12 +116,17 @@ function toConstraintOp(input) {
 /** As `toListOp`, but an added finding also carries the run it is attributed to. */
 function toFindingOp(input) {
     const base = toListOp(input);
-    return base.op === "add" ? { ...base, runId: input.runId } : base;
+    if (base.op !== "add")
+        return base;
+    if (input.runId === undefined)
+        throw new Error("a finding add requires runId");
+    return { ...base, runId: input.runId };
 }
-export function createUpdateWorkingMemoryTool(workingMemory, pool) {
+export const DEFAULT_UPDATE_WORKING_MEMORY_OPTS = { stepKey: durableStepKey };
+export function createUpdateWorkingMemoryTool(workingMemory, pool, opts = DEFAULT_UPDATE_WORKING_MEMORY_OPTS) {
     /** Write one amendment, mapping a refused write to a model-visible error. */
     async function apply(analysisId, section, value) {
-        const written = await workingMemory.updateSection(analysisId, section, value);
+        const written = await workingMemory.updateSection(analysisId, section, value, opts.stepKey());
         if (written.isErr()) {
             // A refused write (cap hit, unknown id) is an expected outcome the model
             // can act on — its message carries the remedy. A DbError is not: it throws,
@@ -161,6 +177,8 @@ export function createUpdateWorkingMemoryTool(workingMemory, pool) {
             const analysisId = scopeResource(ctx.session.scope).resourceId;
             switch (input.section) {
                 case "goal":
+                    if (input.text === undefined)
+                        throw new Error("goal requires text");
                     return apply(analysisId, "goal", { text: input.text });
                 case "constraint":
                     return apply(analysisId, "constraint", toConstraintOp(input));

package/dist/tools/read-tool-output.js

@@ -2,6 +2,8 @@
  * `read_tool_output` — reads the kept text of a tool result that the loop cut, by a window or by a pattern.
  * Each result stays under the cap of the loop, thus the loop never cuts a result of this tool.
  */
+import { errorMessageOf } from "../lib/thrown.js";
+import { textOf } from "../lib/unknown-text.js";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { unwrapOrThrow } from "../lib/result.js";
@@ -61,10 +63,11 @@ function page(ref, text, start, limit) {
 function search(ref, text, start, limit, pattern) {
     let regex;
     try {
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the caller-supplied search pattern is the tool's input; the dynamic form is the feature, and an invalid pattern is the handled error below.
         regex = new RegExp(pattern, "g");
     }
     catch (err) {
-        return { status: "invalid_pattern", pattern, error: err instanceof Error ? err.message : String(err) };
+        return { status: "invalid_pattern", pattern, error: errorMessageOf(err) ?? textOf(err) };
     }
     const stop = limit === undefined ? text.length : windowEnd(text, start, limit);
     const window = text.slice(start, stop);
@@ -97,7 +100,10 @@ function search(ref, text, start, limit, pattern) {
     });
     let result = at(end);
     while (!fits(result) && matches.length > 1) {
-        end = matches.pop().offset;
+        const dropped = matches.pop();
+        if (dropped === undefined)
+            break;
+        end = dropped.offset;
         result = at(end);
     }
     return result;

package/dist/tools/registry.d.ts

@@ -6,10 +6,10 @@
  */
 import { type ToolSet } from "ai";
 import type { Tool } from "./define-tool.js";
-export interface Registry {
+export type Registry = {
     /** The AI SDK tool definitions to send with a chat request. */
     definitions(): ToolSet;
     /** Resolve a tool by name for dispatch; `undefined` if unknown. */
     get(name: string): Tool | undefined;
-}
+};
 export declare function createRegistry(tools: readonly Tool[]): Registry;