@inflexa-ai/harness 0.44.0 → 0.45.1

package/dist/reference-data/catalog.js

@@ -294,6 +294,30 @@ export const REFERENCE_DATA_CATALOG = deepFreeze(ReferenceDataCatalogSchema.pars
                 },
             ],
         },
+        {
+            // Two species in one table: no organism field, like omnipath-interactions.
+            id: "mgi-mouse-human-homology",
+            version: "current",
+            title: "MGI mouse-human homology classes",
+            description: "The Mouse Genome Informatics homology reports: the one-to-one mouse-to-human orthologs of the protein-coding genes, and the full homology classes with the sequence identifiers. MGI rebuilds the reports weekly, so they are verified against what you downloaded rather than a checked-in digest.",
+            sourceUrl: "https://www.informatics.jax.org/downloads/reports/index.html",
+            license: { identifier: "CC-BY-4.0", url: "https://www.informatics.jax.org/mgihome/other/copyright.shtml" },
+            recommendation: { group: "gene-identifiers", recommended: false },
+            artifacts: [
+                {
+                    path: "HOM_ProteinCoding.rpt",
+                    url: "https://www.informatics.jax.org/downloads/reports/HOM_ProteinCoding.rpt",
+                    format: "tsv",
+                    contents: "Tab-separated, NO header, about 780 KB, one row per mouse protein-coding gene with a one-to-one human ortholog. Positional columns: 1 MGI accession id, 2 mouse symbol, 3 mouse NCBI gene id, 4 HGNC id, 5 human symbol, 6 human NCBI gene id. The first choice for a mouse-to-human map.",
+                },
+                {
+                    path: "HOM_MouseHumanSequence.rpt",
+                    url: "https://www.informatics.jax.org/downloads/reports/HOM_MouseHumanSequence.rpt",
+                    format: "tsv",
+                    contents: "Tab-separated with a header, about 15 MB, one row per gene. The rows that share a 'DB Class Key' are one homology class across the two species, and a class can hold more than one gene of one species. Key columns: 'Common Organism Name' (mouse, laboratory or human), 'NCBI Taxon ID', Symbol, 'EntrezGene ID', 'Mouse MGI ID', 'HGNC ID'. Use it for a gene absent from the one-to-one file, and report the class size.",
+                },
+            ],
+        },
         {
             id: "reactome-pathways",
             version: "current",
@@ -802,7 +826,7 @@ export const REFERENCE_DATA_CATALOG = deepFreeze(ReferenceDataCatalogSchema.pars
             id: "string-ppi-human",
             version: "12.0",
             title: "STRING human protein-protein interaction network",
-            description: "STRING v12.0 functional protein association network for Homo sapiens: every protein pair with a combined confidence score, the genome-scale graph network-proximity methods measure distances over. Roughly 85 MB across two files — the network itself and the identifier mapping it cannot be read without. Immutable v12.0 release.",
+            description: "STRING v12.0 functional protein association network for Homo sapiens: every protein pair with a combined confidence score, the genome-scale graph network-proximity methods measure distances over. Roughly 85 MB across two files — the network itself and the identifier mapping it cannot be read without. For an exact join to an Ensembl-keyed table, add `string-aliases-human`. Immutable v12.0 release.",
             organism: "human",
             sourceUrl: "https://string-db.org/cgi/access",
             license: { identifier: "CC-BY-4.0", url: "https://creativecommons.org/licenses/by/4.0/" },
@@ -818,7 +842,28 @@ export const REFERENCE_DATA_CATALOG = deepFreeze(ReferenceDataCatalogSchema.pars
                     path: "9606.protein.info.v12.0.txt.gz",
                     url: "https://stringdb-downloads.org/download/protein.info.v12.0/9606.protein.info.v12.0.txt.gz",
                     format: "tsv",
-                    contents: "Gzipped TSV, ~19,700 rows, header '#string_protein_id preferred_name protein_size annotation'. Mandatory rather than supplementary: preferred_name is the gene symbol for each STRING id in the links file, and without this join the network cannot be connected to a gene list, a drug-target set, or any other dataset here.",
+                    contents: "Gzipped TSV, ~19,700 rows, header '#string_protein_id preferred_name protein_size annotation'. Mandatory rather than supplementary: preferred_name is the only name this dataset gives each STRING id of the links file, so without this join the network carries no gene names at all. preferred_name is a symbol, and a symbol join silently drops a renamed gene: for an exact identifier join, add `string-aliases-human` and key on its Ensembl gene id rows instead.",
+                },
+            ],
+        },
+        {
+            // The companion of string-ppi-human. It is its own dataset because a new
+            // artifact on an installed dataset at the same version invalidates the
+            // receipt of every existing install and forces a full re-download.
+            id: "string-aliases-human",
+            version: "12.0",
+            title: "STRING human protein aliases",
+            description: "The STRING v12.0 alias table for Homo sapiens: every external identifier of each STRING protein, with its source. The companion of `string-ppi-human`: its Ensembl gene id rows give the exact join from the STRING network to a GTEx or a GENCODE table, which the symbol of the info file does not give for a renamed gene. About 20 MB. Immutable v12.0 release.",
+            organism: "human",
+            sourceUrl: "https://string-db.org/cgi/access",
+            license: { identifier: "CC-BY-4.0", url: "https://creativecommons.org/licenses/by/4.0/" },
+            recommendation: { group: "interaction-networks", recommended: false },
+            artifacts: [
+                {
+                    path: "9606.protein.aliases.v12.0.txt.gz",
+                    url: "https://stringdb-downloads.org/download/protein.aliases.v12.0/9606.protein.aliases.v12.0.txt.gz",
+                    format: "tsv",
+                    contents: "Gzipped TSV, about 20 MB, header '#string_protein_id alias source', many rows per protein. Filter source == 'Ensembl_gene' to get one Ensembl gene id (ENSG) per STRING protein id: the exact join key to a GTEx or a GENCODE table, which the symbol of the info file does not give for a renamed gene.",
                 },
             ],
         },
@@ -864,6 +909,100 @@ export const REFERENCE_DATA_CATALOG = deepFreeze(ReferenceDataCatalogSchema.pars
                 },
             ],
         },
+        {
+            id: "impc-phenotyping",
+            version: "release-24.0",
+            title: "IMPC mouse knockout phenotyping, data release 24.0",
+            description: "The International Mouse Phenotyping Consortium data release 24.0 reports: the significant genotype-to-phenotype assertions, the viability calls, and the procedure completeness of each phenotyped colony. Immutable release directory.",
+            organism: "mouse",
+            sourceUrl: "https://ftp.ebi.ac.uk/pub/databases/impc/all-data-releases/release-24.0/results/",
+            license: { identifier: "CC-BY-4.0", url: "https://www.mousephenotype.org/help/faqs/is-impc-data-freely-available/" },
+            recommendation: { group: "phenotype-annotations", recommended: false },
+            artifacts: [
+                {
+                    path: "genotype-phenotype-assertions-ALL.csv.gz",
+                    url: "https://ftp.ebi.ac.uk/pub/databases/impc/all-data-releases/release-24.0/results/genotype-phenotype-assertions-ALL.csv.gz",
+                    format: "csv",
+                    contents: "Gzipped CSV with a header, about 4.8 MB, one row per significant genotype-phenotype association. Key columns: marker_accession_id (MGI id), marker_symbol, zygosity, top_level_mp_term_id, top_level_mp_term_name, mp_term_id, mp_term_name, p_value, effect_size, resource_name (IMPC, EuroPhenome, MGP, 3i, pwg — matched case-sensitively). zygosity is hemizygote, heterozygote, or homozygote. top_level_mp_term_id holds a comma-separated list on 13,643 of its 67,350 rows, so split it and test membership: equality against MP:0005370 (liver and biliary system) returns 509 rows over 322 genes, membership returns 612 over 351. A gene absent here was either clean or never tested: the completeness file tells which.",
+                },
+                {
+                    path: "procedureCompletenessAndPhenotypeHits.csv.gz",
+                    url: "https://ftp.ebi.ac.uk/pub/databases/impc/all-data-releases/release-24.0/results/procedureCompletenessAndPhenotypeHits.csv.gz",
+                    format: "csv",
+                    contents: "Gzipped CSV with a quoted header, about 24 MB, one row per gene, colony, zygosity, and life stage. The '|'-separated columns 'Procedure Stable Id: Successful' and 'Parameter Name: Successful' say what was tested (the clinical chemistry procedure ids share the prefix IMPC_CBC_, with versions such as IMPC_CBC_001, and parameter names written out in full — 'Alanine aminotransferase', 'Aspartate aminotransferase', 'Alkaline phosphatase', 'Total bilirubin' — never abbreviated to ALT or AST); 'Top-level MP Accession Id: Significant' and 'MP Accession Id: Significant' say what was found. 'Life Stage' is one of seven values, 'Early adult' among them, and 'Zygosity' includes hemizygote beside homozygote and heterozygote. The only file that separates a gene tested with no hit from a gene never tested.",
+                },
+                {
+                    path: "viability.csv.gz",
+                    url: "https://ftp.ebi.ac.uk/pub/databases/impc/all-data-releases/release-24.0/results/viability.csv.gz",
+                    format: "csv",
+                    contents: "Gzipped CSV with a quoted header, about 470 KB, one row per colony and zygosity. Key columns: 'Gene Accession Id' (MGI id), 'Gene Symbol', 'Zygosity', 'Viability Phenotype HOMs/HEMIs' (lowercase: lethal, subviable, viable), 'Supporting Data' (the long form, for example 'Homozygous - Viable'), 'Viability Call Method' (curated or computed). 'Zygosity' is homozygote or hemizygote, so an X-linked knockout carries a hemizygous call and no homozygous one. One gene can hold different calls on different colonies — 14 genes hold both a lethal and a viable call — so lethal takes precedence over subviable and over viable within one gene.",
+                },
+            ],
+        },
+        {
+            id: "hpo-annotations",
+            version: "2026-09-01",
+            title: "Human Phenotype Ontology gene-to-phenotype annotations",
+            description: "The HPO release 2026-09-01: the gene-to-phenotype annotation table derived from OMIM and Orphanet, with the ontology file that gives the term hierarchy. Immutable GitHub release assets.",
+            organism: "human",
+            sourceUrl: "https://github.com/obophenotype/human-phenotype-ontology/releases/tag/v2026-09-01",
+            // The HPO license has no SPDX identifier. Its page gives three conditions: cite the
+            // HPO Consortium, show the version of each HPO file in a public display, and do not
+            // change the files. The installer fetches the files from the upstream and changes
+            // nothing; the acknowledgement in a product is the concern of the product.
+            license: { identifier: "LicenseRef-HPO", url: "https://hpo.jax.org/app/license" },
+            recommendation: { group: "phenotype-annotations", recommended: false },
+            artifacts: [
+                {
+                    path: "genes_to_phenotype.txt",
+                    url: "https://github.com/obophenotype/human-phenotype-ontology/releases/download/v2026-09-01/genes_to_phenotype.txt",
+                    format: "tsv",
+                    contents: "Tab-separated with a header, about 20 MB. Columns: ncbi_gene_id (Entrez), gene_symbol, hpo_id, hpo_name, frequency, disease_id (OMIM or ORPHA). One row per gene, term, and disease, thus a gene repeats. The rows carry the annotated terms only, not their ancestors: take the descendant closure of a root term from hp.obo before a filter.",
+                },
+                {
+                    path: "hp.obo",
+                    url: "https://github.com/obophenotype/human-phenotype-ontology/releases/download/v2026-09-01/hp.obo",
+                    format: "obo",
+                    contents: "The ontology in OBO format, about 11 MB: one [Term] stanza per HP term with id, name, and is_a parents. Walk the is_a edges to take the descendants of a root term, for example HP:0001392 (Abnormality of the liver) or HP:0004297 (Abnormality of the biliary system).",
+                },
+            ],
+        },
+        {
+            // Mouse phenotypes keyed on human Ensembl ids: no single organism, like omnipath-interactions.
+            id: "opentargets-mouse-phenotype",
+            version: "26.09",
+            title: "Open Targets mouse model phenotypes mapped to human targets",
+            description: "The mouse_phenotype dataset of Open Targets Platform 26.09: the IMPC and the MGI literature phenotypes of mouse models, with the human target that Open Targets mapped each mouse gene to. One zstd parquet part. Immutable release.",
+            sourceUrl: "https://ftp.ebi.ac.uk/pub/databases/opentargets/platform/26.09/output/mouse_phenotype/",
+            license: { identifier: "CC0-1.0", url: "https://platform-docs.opentargets.org/licence" },
+            recommendation: { group: "phenotype-annotations", recommended: false },
+            artifacts: [
+                {
+                    path: "mouse_phenotype.parquet",
+                    url: "https://ftp.ebi.ac.uk/pub/databases/opentargets/platform/26.09/output/mouse_phenotype/part-00000-5e904527-9bf6-4fd5-9fc4-5f272954b1f8-c000.zstd.parquet",
+                    format: "parquet",
+                    contents: "Zstd parquet, about 6.5 MB, 203,583 rows, one row per human target, mouse gene, and phenotype term. Columns: targetFromSourceId (human Ensembl gene id), targetInModel (mouse symbol), targetInModelMgiId, targetInModelEnsemblId, modelPhenotypeId (MP id), modelPhenotypeLabel, modelPhenotypeClasses (list of top-level MP id and label), biologicalModels (allele, background, literature). Read with pandas and pyarrow. The mouse-to-human map is the one of Open Targets, which can differ from the MGI homology tables.",
+                },
+            ],
+        },
+        {
+            id: "opentargets-target-safety-event",
+            version: "26.09",
+            title: "Open Targets target safety events",
+            description: "The target_safety_event dataset of Open Targets Platform 26.09: curated safety liabilities per target from the published panels, ToxCast, AOP-Wiki, and ClinPGx, each with the organ or tissue of the event. One zstd parquet part. Immutable release.",
+            organism: "human",
+            sourceUrl: "https://ftp.ebi.ac.uk/pub/databases/opentargets/platform/26.09/output/target_safety_event/",
+            license: { identifier: "CC0-1.0", url: "https://platform-docs.opentargets.org/licence" },
+            recommendation: { group: "phenotype-annotations", recommended: false },
+            artifacts: [
+                {
+                    path: "target_safety_event.parquet",
+                    url: "https://ftp.ebi.ac.uk/pub/databases/opentargets/platform/26.09/output/target_safety_event/part-00000-e457d966-d50e-4afc-841d-547765a1e4d7-c000.zstd.parquet",
+                    format: "parquet",
+                    contents: "Zstd parquet, about 120 KB, 4,387 rows, one row per target and safety event. Columns: targetId (Ensembl gene id), event, eventId (EFO), effects (direction, dosing), biosamples (tissueLabel, tissueId as UBERON, cell fields), datasource, literature (PMID), studies. biosamples is null on 1,786 rows, so guard the test. tissueId carries one term in two spellings — UBERON_0002107 on 74 rows, UBERON:0002107 on 6 — and event is free text in mixed case ('Hepatotoxicity', 'Increased, Liver Steatosis'), so match both spellings and ignore case: a liver filter then flags 88 targets rather than 57. The sources are curated panels, not an exhaustive list: absence is not safety.",
+                },
+            ],
+        },
         {
             id: "celltypist-immune",
             version: "2",

package/dist/report-model/authoring-grammar.d.ts

@@ -38,9 +38,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
     }, z.core.$strict>;
     bindings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-value">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-value">;
         unit: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
         locator: z.ZodObject<{
             column: z.ZodString;
             rowFilter: z.ZodOptional<z.ZodObject<{
@@ -55,12 +56,12 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
             tolerance: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         run: z.ZodOptional<z.ZodString>;
-        snapshot: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-table">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-table">;
         unit: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
         rowBound: z.ZodOptional<z.ZodObject<{
             column: z.ZodString;
             count: z.ZodNumber;
@@ -79,14 +80,13 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         }>>>;
         columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         run: z.ZodOptional<z.ZodString>;
-        snapshot: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-file">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-file">;
         unit: z.ZodOptional<z.ZodString>;
-        run: z.ZodOptional<z.ZodString>;
         snapshot: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
@@ -102,9 +102,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         }, z.core.$strict>>;
         inputs: z.ZodArray<z.ZodObject<{
             format: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<"artifact-value">;
             path: z.ZodString;
+            kind: z.ZodLiteral<"artifact-value">;
             unit: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodString>;
             locator: z.ZodObject<{
                 column: z.ZodString;
                 rowFilter: z.ZodOptional<z.ZodObject<{
@@ -119,7 +120,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
                 tolerance: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             run: z.ZodOptional<z.ZodString>;
-            snapshot: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>, z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
@@ -142,9 +142,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
     label: z.ZodString;
     value: z.ZodDiscriminatedUnion<[z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-value">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-value">;
         unit: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
         locator: z.ZodObject<{
             column: z.ZodString;
             rowFilter: z.ZodOptional<z.ZodObject<{
@@ -159,7 +160,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
             tolerance: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         run: z.ZodOptional<z.ZodString>;
-        snapshot: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         unit: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
@@ -175,9 +175,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         }, z.core.$strict>>;
         inputs: z.ZodArray<z.ZodObject<{
             format: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<"artifact-value">;
             path: z.ZodString;
+            kind: z.ZodLiteral<"artifact-value">;
             unit: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodString>;
             locator: z.ZodObject<{
                 column: z.ZodString;
                 rowFilter: z.ZodOptional<z.ZodObject<{
@@ -192,7 +193,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
                 tolerance: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             run: z.ZodOptional<z.ZodString>;
-            snapshot: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>, z.ZodObject<{
@@ -202,9 +202,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
     caption: z.ZodOptional<z.ZodString>;
     binding: z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-table">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-table">;
         unit: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
         rowBound: z.ZodOptional<z.ZodObject<{
             column: z.ZodString;
             count: z.ZodNumber;
@@ -223,14 +224,14 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         }>>>;
         columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         run: z.ZodOptional<z.ZodString>;
-        snapshot: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     binding: z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-table">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-table">;
         unit: z.ZodOptional<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodString>;
         rowBound: z.ZodOptional<z.ZodObject<{
             column: z.ZodString;
             count: z.ZodNumber;
@@ -249,15 +250,15 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         }>>>;
         columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         run: z.ZodOptional<z.ZodString>;
-        snapshot: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     statistics: z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         value: z.ZodObject<{
             format: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<"artifact-value">;
             path: z.ZodString;
+            kind: z.ZodLiteral<"artifact-value">;
             unit: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodString>;
             locator: z.ZodObject<{
                 column: z.ZodString;
                 rowFilter: z.ZodOptional<z.ZodObject<{
@@ -272,7 +273,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
                 tolerance: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             run: z.ZodOptional<z.ZodString>;
-            snapshot: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
     }, z.core.$strict>>>;
     track: z.ZodOptional<z.ZodObject<{
@@ -282,9 +282,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
         length: z.ZodOptional<z.ZodString>;
         binding: z.ZodObject<{
             format: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<"artifact-table">;
             path: z.ZodString;
+            kind: z.ZodLiteral<"artifact-table">;
             unit: z.ZodOptional<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodString>;
             rowBound: z.ZodOptional<z.ZodObject<{
                 column: z.ZodString;
                 count: z.ZodNumber;
@@ -303,7 +304,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
             }>>>;
             columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             run: z.ZodOptional<z.ZodString>;
-            snapshot: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
     trees: z.ZodOptional<z.ZodObject<{
@@ -313,9 +313,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
             height: z.ZodString;
             binding: z.ZodObject<{
                 format: z.ZodOptional<z.ZodString>;
-                kind: z.ZodLiteral<"artifact-table">;
                 path: z.ZodString;
+                kind: z.ZodLiteral<"artifact-table">;
                 unit: z.ZodOptional<z.ZodString>;
+                snapshot: z.ZodOptional<z.ZodString>;
                 rowBound: z.ZodOptional<z.ZodObject<{
                     column: z.ZodString;
                     count: z.ZodNumber;
@@ -334,7 +335,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
                 }>>>;
                 columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 run: z.ZodOptional<z.ZodString>;
-                snapshot: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>;
         }, z.core.$strict>>;
         y: z.ZodOptional<z.ZodObject<{
@@ -343,9 +343,10 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
             height: z.ZodString;
             binding: z.ZodObject<{
                 format: z.ZodOptional<z.ZodString>;
-                kind: z.ZodLiteral<"artifact-table">;
                 path: z.ZodString;
+                kind: z.ZodLiteral<"artifact-table">;
                 unit: z.ZodOptional<z.ZodString>;
+                snapshot: z.ZodOptional<z.ZodString>;
                 rowBound: z.ZodOptional<z.ZodObject<{
                     column: z.ZodString;
                     count: z.ZodNumber;
@@ -364,7 +365,6 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
                 }>>>;
                 columnLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 run: z.ZodOptional<z.ZodString>;
-                snapshot: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
@@ -817,11 +817,11 @@ declare const AUTHORING_ATOM_SCHEMAS: readonly [z.ZodObject<{
     caption: z.ZodOptional<z.ZodString>;
     binding: z.ZodObject<{
         format: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"artifact-file">;
         path: z.ZodString;
+        kind: z.ZodLiteral<"artifact-file">;
         unit: z.ZodOptional<z.ZodString>;
-        run: z.ZodOptional<z.ZodString>;
         snapshot: z.ZodOptional<z.ZodString>;
+        run: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"citation">;

package/dist/report-model/pin-snapshot.d.ts

@@ -18,7 +18,7 @@
  */
 import { type Result } from "neverthrow";
 import type { Querier } from "../state/db.js";
-import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
+import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 import type { ReportSnapshot } from "./reference-resolver.js";
 /**
  * The reason that the pin gave no snapshot. The ledger read and the run listing are the two operations

package/dist/report-model/pin-snapshot.js

@@ -17,54 +17,11 @@
  * keeps the membership role, thus the record map is optional and it changes no resolution.
  */
 import { err, ok } from "neverthrow";
-import { open } from "node:fs/promises";
-import { join } from "node:path";
-import { tryFs } from "../lib/fs-result.js";
+import { readSynthesisText } from "../execution/run-synthesis.js";
 import { queryAnalysisArtifacts } from "../state/artifacts.js";
 import { queryRunsByAnalysis } from "../state/runs.js";
-import { isSafeId, runDir } from "../workspace/paths.js";
-/** The file name of the synthesis record inside the run directory. */
-const SYNTHESIS_FILE = "synthesis.json";
-/**
- * The cap of one synthesis read. A synthesis record is small by construction, and the cap bounds the
- * cost of a file that is not. A file over the cap gives no key, because a cut JSON text cannot parse.
- */
-const SYNTHESIS_CAP_BYTES = 1024 * 1024;
 /** The page size of the run listing. The listing walks the pages until a short page ends the walk. */
 const RUN_PAGE_SIZE = 200;
-/**
- * Read a synthesis record under the cap, or give `undefined` when the bytes do not come back.
- *
- * The read takes a bounded byte window, thus a file of any size costs the cap. An absent file, a genuine
- * read fault, and a file over the cap each give `undefined`, because the collection reports no error for
- * one record.
- */
-async function readSynthesisText(absolute) {
-    return tryFs("pinReportSnapshot.readSynthesis", async () => {
-        const handle = await open(absolute, "r");
-        try {
-            // The window takes one byte more than the cap. A read that fills it states that the file
-            // holds more bytes than the cap admits, thus the two conditions stay apart.
-            const buffer = Buffer.alloc(SYNTHESIS_CAP_BYTES + 1);
-            // One read of a network-backed file can give fewer bytes than the window holds. Such a
-            // short read cuts the text in the middle of the JSON, and the record then parses to no
-            // key at all. Thus the loop reads again from the offset that the last read reached, and
-            // it stops when the window fills or when a read gives no byte.
-            let filled = 0;
-            while (filled < buffer.length) {
-                const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
-                if (bytesRead === 0) {
-                    break;
-                }
-                filled += bytesRead;
-            }
-            return filled > SYNTHESIS_CAP_BYTES ? undefined : buffer.subarray(0, filled).toString("utf8");
-        }
-        finally {
-            await handle.close();
-        }
-    }, { path: absolute, onAbsent: () => undefined }).unwrapOr(undefined);
-}
 /** The trimmed text of a field, or `undefined` when the field is not a non-empty string. */
 function trimmedText(value) {
     if (typeof value !== "string") {
@@ -181,12 +138,7 @@ async function collectCitations(pool, resolveWorkspaceRoot, analysisId) {
             return err({ kind: "run-listing-failed", cause: page.error.cause });
         }
         for (const run of page.value) {
-            // The path builder refuses an id that can escape the run tree. A refusal is a throw, thus
-            // the guard keeps the collection on the value channel.
-            if (!isSafeId(run.runId)) {
-                continue;
-            }
-            const text = await readSynthesisText(join(root, runDir(run.runId), SYNTHESIS_FILE));
+            const text = await readSynthesisText({ workspaceRoot: root, runId: run.runId });
             if (text === undefined) {
                 continue;
             }

package/dist/runtime/assemble.d.ts

@@ -14,8 +14,9 @@
  * `applicationVersion` stamp because all registration happens in this one call,
  * before launch — a blue/green drain treats them as a single cohort.
  */
-import { type Result } from "neverthrow";
+import { type Result, type ResultAsync } from "neverthrow";
 import { type ConversationAgentDeps } from "../agents/conversation-agent.js";
+import { type ApprovePlanInput, type ApprovePlanRefusal, type PlanApproval } from "../app/approve-plan.js";
 import { type ReportSessionRuntime } from "../app/report-session-runtime.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { ResourcePolicy } from "../config/resource-limits.js";
@@ -235,6 +236,12 @@ export interface CoreRuntime {
     readonly reportSession: Pick<ReportSessionRuntime, "ensureSessionState">;
     readonly workflows: RegisteredWorkflows;
     readonly citationResolver: CitationResolver;
+    /**
+     * Approve a stored plan by its id and start its run with no model call. It runs over the deps that
+     * reach the `execute_analysis` tool of the conversation agent, thus the approval and the tool launch
+     * a plan the same way.
+     */
+    readonly approvePlan: (input: ApprovePlanInput) => ResultAsync<PlanApproval, ApprovePlanRefusal>;
 }
 /**
  * The eyes of the composition, or none.

package/dist/runtime/assemble.js

@@ -17,6 +17,7 @@
 import { err, ok } from "neverthrow";
 import { createConversationAgent } from "../agents/conversation-agent.js";
 import { createReportSessionAgent } from "../agents/report-session-agent.js";
+import { approvePlan } from "../app/approve-plan.js";
 import { createReportSessionRuntime } from "../app/report-session-runtime.js";
 import { createNoopUsageRecorder } from "../billing/noop-usage-recorder.js";
 import { hasBrowserUrl } from "../lib/chrome.js";
@@ -210,5 +211,15 @@ export function assembleCoreRuntime(deps) {
             deriveTableExec,
         },
         citationResolver,
+        approvePlan: (input) => approvePlan({
+            pool: conversation.pool,
+            executeAnalysisWorkflow: executeAnalysis,
+            runAuthorizer: conversation.runAuthorizer,
+            runLauncher: conversation.runLauncher,
+            ...(resourcePolicy ? { resourcePolicy } : {}),
+            ...(conversation.extendAnalysisFarm ? { extendAnalysisFarm: conversation.extendAnalysisFarm } : {}),
+            ...(conversation.logger ? { logger: conversation.logger } : {}),
+            ...(deps.provenance ? { provenance: deps.provenance } : {}),
+        }, input),
     };
 }

package/dist/runtime/boot.d.ts

@@ -25,6 +25,9 @@
  *      legacy-workflow reap, an agent-switch install). Runs after registration
  *      so it may close over the registered callables.
  *   7. `launchDbos(...)` — the last registration-dependent step.
+ *   8. `reconcileOrphanedRuns(pool)` — fails each `running` run whose workflow never started. It runs
+ *      after launch, thus a workflow that recovery re-queued counts as started. A failure is logged and does
+ *      not stop the boot, because the repair only frees the slot of a plan.
  *
  * No step reads or rewrites stored conversation display. A boot that validated
  * every `messages` row is what let a single retired part key fail startup for a

package/dist/runtime/boot.js

@@ -25,6 +25,9 @@
  *      legacy-workflow reap, an agent-switch install). Runs after registration
  *      so it may close over the registered callables.
  *   7. `launchDbos(...)` — the last registration-dependent step.
+ *   8. `reconcileOrphanedRuns(pool)` — fails each `running` run whose workflow never started. It runs
+ *      after launch, thus a workflow that recovery re-queued counts as started. A failure is logged and does
+ *      not stop the boot, because the repair only frees the slot of a plan.
  *
  * No step reads or rewrites stored conversation display. A boot that validated
  * every `messages` row is what let a single retired part key fail startup for a
@@ -38,6 +41,7 @@
 import { SANDBOX_AGENT_META } from "../agents/sandbox/index.js";
 import { validateAgentSkills } from "../agents/sandbox/validate-skills.js";
 import { initCortexState } from "../state/init.js";
+import { reconcileOrphanedRuns } from "../state/runs.js";
 import { assembleCoreRuntime } from "./assemble.js";
 import { assertConnectionBudget } from "./connection-budget.js";
 import { launchDbos, shutdownDbos } from "./dbos.js";
@@ -56,7 +60,12 @@ export async function bootHarness(deps) {
     const runtime = assembleCoreRuntime(core);
     await deps.beforeLaunch?.();
     await launchDbos({ config: deps.dbos, logger });
-    logger.named("boot").info("harness booted", { executorId: deps.dbos.executorId });
+    const bootLog = logger.named("boot");
+    (await reconcileOrphanedRuns(pool)).match((runIds) => {
+        if (runIds.length > 0)
+            bootLog.warn("failed the runs whose workflow never started", { runIds });
+    }, (error) => bootLog.warn("the repair of the orphaned runs failed", bootLog.errorFields(error)));
+    bootLog.info("harness booted", { executorId: deps.dbos.executorId });
     const shutdown = (signal) => runShutdownSequence({
         signal,
         logger,

package/dist/sandbox/image-packages.d.ts

@@ -1,9 +1,11 @@
 /**
  * `image-packages.json` — the self-description of the sandbox image.
  *
- * The image bakes two package tracks that the content-addressed store cannot
- * hold: the conda tools at `/opt/conda` and the Node packages at `/opt/node`.
- * The image writes one record of them at `/opt/inflexa/image-packages.json`,
+ * The image bakes the package tracks that the content-addressed store cannot
+ * hold: the conda tools at `/opt/conda`, the Node packages at `/opt/node`,
+ * and the R packages that ship with the R runtime (the base and the
+ * recommended packages, which no farm lock lists). The image writes one
+ * record of them at `/opt/inflexa/image-packages.json`,
  * and the catalog build copies that record verbatim into the root of the
  * package store it packed beside it. Thus every reader of a store learns the
  * image inventory from the store alone — with no container engine, no
@@ -57,10 +59,22 @@ export declare const ImageNodePackageSchema: z.ZodObject<{
     name: z.ZodString;
     version: z.ZodString;
 }, z.core.$loose>;
+/** One R package that ships with the R runtime of the image: a base package or a recommended package. */
+export declare const ImageRBasePackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    priority: z.ZodEnum<{
+        base: "base";
+        recommended: "recommended";
+    }>;
+}, z.core.$loose>;
 /**
  * `image-packages.json` at schema version 1. The keys `system_tools` and
  * `node` are the keys of the image manifest, thus one name means one track
- * across the build and the reader.
+ * across the build and the reader. `r_base` is the track of the R runtime
+ * itself: the packages R ships, which no manifest names and no farm lock
+ * lists. It is optional, because a record from before the field existed is
+ * still a valid record of its image.
  */
 export declare const ImagePackagesSchema: z.ZodObject<{
     schema: z.ZodLiteral<1>;
@@ -86,6 +100,14 @@ export declare const ImagePackagesSchema: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
     }, z.core.$loose>>;
+    r_base: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        priority: z.ZodEnum<{
+            base: "base";
+            recommended: "recommended";
+        }>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export type ImagePackages = z.infer<typeof ImagePackagesSchema>;
 export type ImagePackagesError = {