@ai-matrx/records 0.20.0 → 0.24.0

package/CHANGELOG.md

@@ -1,7 +1,80 @@
 # Changelog — @ai-matrx/records
 
 
-## 0.20.0 — 2026-09-20
+
+## 0.24.0 — 2026-09-20
+
+**0.23.0 never reached npm.** Its release run died before any package could be
+built: five `node_modules` SYMLINKS, each pointing at an absolute path inside
+one machine's checkout, had been committed to the repository, and on a CI runner
+a dangling symlink makes `pnpm install --frozen-lockfile` answer ENOENT. Every
+package release was blocked, not just this one. The symlinks are untracked and
+`.gitignore` now carries both spellings — `node_modules/` with the slash matches
+a directory only, which is how a symlink of that name walked past it. This
+version is 0.23.0's contents from the repaired tree; a tag is never moved, so
+0.23.0 is simply absent from npm.
+
+
+## 0.23.0
+
+**A column a model owns — seven doors, and the four states one cell can be in.**
+
+`enrichments`, `enrichDeclare`, `enrichDue`, `enrichCells`, `enrichLand`,
+`enrichPin` and `enrichRuns` (PRODUCTS row 10 / AGT-6). An Enrichment is not a new
+object: it IS the Field, saying `source = agent`, with its instruction, inputs,
+model, confidence floor and freshness in `source_config` and
+`review_interval_days` — so nothing here is keyed by an enrichment id.
+
+`EnrichCell` is the type a screen draws a badge from, and it is deliberately able
+to say four different things, because they are four different facts: a value an
+agent wrote (with the model, what it read and how sure it was), a value a person
+took back (`pinned`), an answer the model would not commit to (`absent_reason:
+"conflicting"`, the guess in `alternates[0]`), and a value past its freshness date
+(`stale` — still holding its value; stale marks it, it never erases it).
+
+`enrichCells` answers a WHOLE PAGE in one call. Asked per cell it is one round trip
+per badge.
+
+The door catalogue is regenerated from the live store: 478 doors.
+
+## 0.22.0 — 2026-09-20
+
+**BREAKING: a parse is a parse. `importCsv` / `importXlsx` no longer take the Fields.**
+
+Found by looking at the import screen, not by reading it. The plan showed *"every
+row in this column is empty, so there is nothing to go on"* for columns plainly
+full of values, and every unmapped column's sample list was blank.
+
+The cause was in this package. The parse took the Fields, matched each heading by
+key or label, keyed the rows by whatever it matched and **dropped every column it
+did not**. That is a mapping decision, made by the one component that must not
+make it: the rows handed to `custom.io_import_rows` carried nothing for the
+unmatched columns, so the store never saw them and could not offer a single one as
+a new column. The whole "never a junk bag" half of SCR-N-7 was unreachable through
+that screen — and it shipped in **0.21.0**, so anyone on that version has it.
+
+Fixed in the SHAPE rather than beside it. These functions no longer take `fields`
+at all, so a parse cannot decide a mapping even by accident:
+
+```ts
+// before
+importCsv(fields, text)   // -> { columns: [{header, field}], rows, unmapped }
+// after
+importCsv(text)           // -> { headers, rows }   rows keyed by heading
+```
+
+`ParsedImport` is now `{ headers: string[]; rows: Array<Record<string, string>> }`
+— every heading, every row keyed by heading, nothing dropped — with no `field`, no
+`unmapped`, and **no safe path left standing beside the unsafe one**. Only the door
+decides. `parseCsv`, `exportCsv`, `exportXlsx`, `toAoa` and `cellText` are
+unchanged.
+
+**Migrating:** drop the first argument, and send `rows` straight to
+`custom.io_import_rows` — the store matches the headings and offers what it could
+not match. A caller that genuinely wants the old pre-matched shape can build it
+from `headers` in four lines, which is what this package's own red twin does.
+
+## 0.21.0 — 2026-09-20
 
 **The store moved and this package's census caught it — twice.** The release
 gate runs the live-door suite against the real record store, and it went red on
@@ -18,6 +91,40 @@ main:
   are: the call named a value the shape does not accept, and the store's own
   sentence names the number and the range.
 
+> **About 0.20.0 on npm.** This lane tagged `0.20.0` from a commit that carried
+> the census fixes above but NOT the checklist doors below — the tag was pushed
+> while a merge of main was still open, and a tag is never moved. `0.21.0` is
+> the first version that carries both. Nobody should sit on 0.20.0.
+
+
+## 0.20.0
+
+**"Every new hire gets these twelve steps." — the checklist doors, PRODUCTS row 13.**
+
+A checklist template is a record of the store: ordered steps, each with the role
+that owns it, how many days in it is due, what it waits for and what it asks for
+before it counts as done, plus the thing that starts a run. Starting one makes
+ONE work item per step in the one work layer — assigned by role to real people,
+dated from the offsets, dependencies carried across — so a step appears in the
+person's ordinary inbox beside everything else and there is no
+checklist-shaped queue anywhere.
+
+Nine doors, all of them live on the main database:
+`checklistRefusal` (pure — a screen may ask it on every keystroke, and the
+refusal arrives before the save), `checklistDeclare`, `checklistTemplates`,
+`checklistTemplateShape`, `checklistStart`, `checklistRun`, `checklistRuns`,
+`checklistStepComplete`, `checklistStepRefusal`.
+
+`ChecklistRunStep` carries `blocked_by`, `refusal`, `may_complete` and
+`requires_key`, so a screen can say why a step cannot be finished yet — in the
+words a person would use — before anybody clicks, file the evidence under the
+key the checklist itself named, and show no control at all where a control would
+fail.
+
+THE DEPENDENCY RULE LIVES IN THE STORE, not in these methods: a BEFORE trigger
+on `custom.record` refuses a step reaching Done while a step it waits for is
+open, so `workSetState` meets the same sentence `checklistStepComplete` does.
+
 
 ## 0.19.0
 
@@ -34,6 +141,23 @@ cannot unzip a workbook; **everything after the parse is the store's**, so a fil
 imported from a screen, from an agent and from a script land identically and
 there is no second importer in this package to drift.
 
+**BREAKING, and it is the point: `importCsv` / `importXlsx` no longer take the
+Fields.** They took them, matched each heading to a Field by key or label, keyed
+the rows by whatever they matched and **dropped every column they did not** —
+and that cannot be the input to a door whose whole job is to decide the mapping
+and offer what it could not match. Measured by looking at the screen: every
+unmapped column's samples came back empty and its proposal read *"every row in
+this column is empty, so there is nothing to go on"* for columns plainly full of
+values. The store can only offer a column whose values reached it.
+
+`ParsedImport` is now `{ headers: string[]; rows: Array<Record<string, string>> }`
+— every heading, every row keyed by heading, nothing dropped — and there is no
+`field`, no `unmapped` and no way to ask for one. The fix is the SHAPE rather
+than a second field beside the first: a parse that is not given the Fields
+cannot decide a mapping even by accident, and no safe path is left standing
+beside an unsafe one. `parseCsv`, `exportCsv`, `exportXlsx`, `toAoa` and
+`cellText` are unchanged.
+
 - **`importPlan({ table_id, columns })`** — what the store makes of a file's
   columns before anything is written, reading the parity map AND this
   organization: an address that belongs to a member is a `member` column, a few
@@ -70,7 +194,6 @@ New types in `@ai-matrx/records`: `ImportPlan`, `ImportColumnPlan`,
 `InboundAddress`, `InboundDeclared`.
 
 `store.generated.ts` regenerated against the live store: **428 doors**.
-
 ## 0.18.0
 
 **"Who changed this price, and can I put it back?" — the doors for PRODUCTS row 4.**

package/dist/core/index.cjs

@@ -2085,6 +2085,22 @@ var DOORS = {
   dashboardRun: "dashboard_run",
   dashboardStuck: "dashboard_stuck",
   dashboardDelete: "dashboard_delete",
+  // PRODUCTS row 10 — "fill in each company's industry and headcount, and keep
+  // it fresh". An Enrichment is not an object of its own: it is a Field saying
+  // `source = agent`, with its instruction, inputs, model, confidence floor and
+  // freshness in `source_config` (AGT-6). `enrichCells` is the one a GRID calls —
+  // the badge data for a whole page in one round trip, because a badge asked per
+  // cell is fifty round trips to draw fifty badges. `enrichPin` is the half of
+  // this product that decides whether anybody ever trusts it: the moment a
+  // person types over an agent-owned cell the store pins it, and the next run
+  // leaves it exactly as they left it.
+  enrichments: "enrichments",
+  enrichDeclare: "enrich_declare",
+  enrichDue: "enrich_due",
+  enrichCells: "enrich_cells",
+  enrichLand: "enrich_land",
+  enrichPin: "enrich_pin",
+  enrichRuns: "enrich_runs",
   // PRODUCTS row 4 — "Who changed this price, and can I put it back?" The
   // history has been in the store since W3-HIST; until 2026-09-20 the only way
   // to ask for it was `io_revisions`, which answers a raw uuid for the author
@@ -2214,6 +2230,16 @@ var DOORS = {
   workApprovalMayDecide: "work_approval_may_decide",
   workApprovalDecide: "work_approval_decide",
   workApprovalRead: "work_approval_read",
+  // PRODUCTS row 13 — checklists and SOP runs.
+  checklistRefusal: "checklist_refusal",
+  checklistDeclare: "checklist_declare",
+  checklistTemplates: "checklist_templates",
+  checklistTemplateShape: "checklist_template_shape",
+  checklistStart: "checklist_start",
+  checklistRun: "checklist_run",
+  checklistRuns: "checklist_runs",
+  checklistStepComplete: "checklist_step_complete",
+  checklistStepRefusal: "checklist_step_refusal",
   // Declared here BECAUSE they do not exist yet: naming them is what makes the
   // absence visible to `pnpm check:store-registry` and to the suite.
   metadataSearch: "metadata_search",
@@ -2992,6 +3018,67 @@ function createRecordsClient(config) {
         "ruleEval"
       );
     },
+    async enrichments(args) {
+      return callDoor(
+        DOORS.enrichments,
+        { p_organization_id: org, p_table_id: args?.table_id ?? null },
+        "enrichments"
+      );
+    },
+    async enrichDeclare(args) {
+      return callDoor(
+        DOORS.enrichDeclare,
+        { p_organization_id: org, p_field_id: args.field_id, p_spec: args.spec },
+        "enrichDeclare"
+      );
+    },
+    async enrichDue(args) {
+      return callDoor(
+        DOORS.enrichDue,
+        {
+          p_organization_id: org,
+          p_field_id: args.field_id,
+          p_limit: args.limit ?? 50,
+          p_include_fresh: args.include_fresh ?? false
+        },
+        "enrichDue"
+      );
+    },
+    async enrichCells(args) {
+      return callDoor(
+        DOORS.enrichCells,
+        {
+          p_organization_id: org,
+          p_table_id: args.table_id,
+          p_field_keys: args.field_keys ?? null,
+          p_record_ids: args.record_ids ?? null
+        },
+        "enrichCells"
+      );
+    },
+    async enrichPin(args) {
+      return callDoor(
+        DOORS.enrichPin,
+        {
+          p_organization_id: org,
+          p_record_id: args.record_id,
+          p_field_key: args.field_key,
+          p_pinned: args.pinned ?? true
+        },
+        "enrichPin"
+      );
+    },
+    async enrichRuns(args) {
+      return callDoor(
+        DOORS.enrichRuns,
+        {
+          p_organization_id: org,
+          p_field_id: args?.field_id ?? null,
+          p_limit: args?.limit ?? 50
+        },
+        "enrichRuns"
+      );
+    },
     async dashboards(args) {
       return callDoor(
         DOORS.dashboards,
@@ -3552,6 +3639,86 @@ function createRecordsClient(config) {
         "workSlotExpire"
       );
     },
+    // ── checklists and SOP runs ──────────────────────────────────────────
+    async checklistRefusal({ spec }) {
+      return callDoor(
+        DOORS.checklistRefusal,
+        { p_spec: spec },
+        "checklistRefusal"
+      );
+    },
+    async checklistDeclare({ spec, template_id = null }) {
+      return callDoor(
+        DOORS.checklistDeclare,
+        { p_organization_id: org, p_spec: spec, p_template_id: template_id },
+        "checklistDeclare"
+      );
+    },
+    async checklistTemplates(args) {
+      return callDoor(
+        DOORS.checklistTemplates,
+        {
+          p_organization_id: org,
+          p_about_table_id: args?.about_table_id ?? null,
+          p_limit: args?.limit ?? 100
+        },
+        "checklistTemplates"
+      );
+    },
+    async checklistTemplateShape({ template_id }) {
+      return callDoor(
+        DOORS.checklistTemplateShape,
+        { p_organization_id: org, p_template_id: template_id },
+        "checklistTemplateShape"
+      );
+    },
+    async checklistStart({ template_id, about_record_id = null, roles = {}, startingAt = null }) {
+      return callDoor(
+        DOORS.checklistStart,
+        {
+          p_organization_id: org,
+          p_template_id: template_id,
+          p_about_record_id: about_record_id,
+          p_roles: roles,
+          p_starting_at: startingAt
+        },
+        "checklistStart"
+      );
+    },
+    async checklistRun({ run_id }) {
+      return callDoor(
+        DOORS.checklistRun,
+        { p_organization_id: org, p_run_id: run_id },
+        "checklistRun"
+      );
+    },
+    async checklistRuns(args) {
+      return callDoor(
+        DOORS.checklistRuns,
+        {
+          p_organization_id: org,
+          p_about_table_id: args?.about_table_id ?? null,
+          p_about_record_id: args?.about_record_id ?? null,
+          p_include_closed: args?.includeClosed ?? true,
+          p_limit: args?.limit ?? 100
+        },
+        "checklistRuns"
+      );
+    },
+    async checklistStepComplete({ step_id, evidence = {} }) {
+      return callDoor(
+        DOORS.checklistStepComplete,
+        { p_organization_id: org, p_step_id: step_id, p_evidence: evidence },
+        "checklistStepComplete"
+      );
+    },
+    async checklistStepRefusal({ step_id }) {
+      return callDoor(
+        DOORS.checklistStepRefusal,
+        { p_organization_id: org, p_step_id: step_id },
+        "checklistStepRefusal"
+      );
+    },
     // ── the work layer a person actually uses ────────────────────────────
     async workInbox(args) {
       return callDoor(
@@ -4210,10 +4377,6 @@ async function exportXlsx(fields, rows, sheetLabel = "Records") {
   XLSX.utils.book_append_sheet(workbook, worksheet, name);
   return XLSX.write(workbook, { type: "array", bookType: "xlsx", compression: true });
 }
-function matchField(header, fields) {
-  const wanted = header.trim().toLowerCase();
-  return fields.find((f) => f.key.toLowerCase() === wanted) ?? fields.find((f) => (f.label ?? "").toLowerCase() === wanted) ?? null;
-}
 function parseCsv(text) {
   const rows = [];
   let row = [];
@@ -4248,31 +4411,30 @@ function parseCsv(text) {
   }
   return rows;
 }
-function importCsv(fields, text) {
-  return fromMatrix(fields, parseCsv(text));
+function importCsv(text) {
+  return fromMatrix(parseCsv(text));
 }
-async function importXlsx(fields, bytes) {
+async function importXlsx(bytes) {
   const XLSX = await import("xlsx");
   const workbook = XLSX.read(bytes, { type: "array" });
   const first = workbook.SheetNames[0];
-  if (!first) return { columns: [], rows: [], unmapped: [] };
+  if (!first) return { headers: [], rows: [] };
   const sheet = workbook.Sheets[first];
-  if (!sheet) return { columns: [], rows: [], unmapped: [] };
+  if (!sheet) return { headers: [], rows: [] };
   const matrix = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false, defval: "" });
-  return fromMatrix(fields, matrix);
+  return fromMatrix(matrix);
 }
-function fromMatrix(fields, matrix) {
+function fromMatrix(matrix) {
   const [header, ...body] = matrix;
-  if (!header) return { columns: [], rows: [], unmapped: [] };
-  const columns = header.map((text) => ({ header: text, field: matchField(text, fields) }));
-  const unmapped = columns.filter((c) => c.field === null).map((c) => c.header).filter((h) => h.trim().length > 0);
+  if (!header) return { headers: [], rows: [] };
+  const headers = header.map((text) => String(text ?? ""));
   const rows = body.filter((line) => line.some((cell) => String(cell ?? "").trim().length > 0)).map((line) => {
     const record = {};
-    columns.forEach((column, index) => {
-      if (column.field) record[column.field.key] = String(line[index] ?? "");
+    headers.forEach((heading, index) => {
+      if (heading.trim().length > 0) record[heading] = String(line[index] ?? "");
     });
     return record;
   });
-  return { columns, rows, unmapped };
+  return { headers, rows };
 }
 //# sourceMappingURL=index.cjs.map