@mulmoclaude/core 0.23.0 → 0.24.0

package/assets/helps/collection-skills.md

@@ -132,8 +132,8 @@ skipped, never crashes the host):
 | `singleton`            | Optional. When set, at most one record exists, pinned to this exact id (e.g. `me`). Host pre-fills + locks the create form and hides Add once it exists.                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `fields`               | Ordered map of field-name → field spec. **Insertion order = column order** in the table. Required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `actions`              | Optional array of per-record buttons (see below).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `completionField`      | Optional. Name of the field whose value marks an item as "done" — when set, item-create fires a bell notification that clears once the field reaches one of `completionDoneValues`. Must name a real field in `fields`. Paired with `completionDoneValues` (both set, or both omitted).                                                                                                                                                                                                                                                                                            |
-| `completionDoneValues` | Optional. Non-empty array of values that count as "done" for `completionField` (e.g. `["Done"]`, `["paid", "void"]`). Compared as strings.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `completionField`      | Optional. Name of the field whose value marks an item as "done" — when set, item-create fires a bell notification that clears once the item reads as done. Must name a real field in `fields`. Two forms: paired with `completionDoneValues` (done ⇔ the field's value is in that array), or naming a **`flag` field** (done ⇔ the flag's `where` matches — `completionDoneValues` must then be omitted).                                                                                                                                                                            |
+| `completionDoneValues` | Optional. Non-empty array of values that count as "done" for `completionField` (e.g. `["Done"]`, `["paid", "void"]`). Compared as strings. Omit when `completionField` names a `flag` field.                                                                                                                                                                                                                                                                                                                                                                                       |
 | `notifyWhen`           | Optional. A `when` predicate (`{ "field": "...", "in": [...] }`) that **gates** the completion bell: fire it only for records matching the predicate (e.g. `{ "field": "priority", "in": ["high", "urgent"] }`). Requires `completionField`; `field` must name a real field. Absent ⇒ notify for every open record.                                                                                                                                                                                                                                                                |
 | `displayField`         | Optional. Name of a field whose value is shown as the human-readable label in the completion notification's title (e.g. `Contacts: Jane Doe` instead of the opaque primaryKey). Must name a real field in `fields`. Falls back to the primaryKey value when unset or when the record's value is empty.                                                                                                                                                                                                                                                                             |
 | `triggerField`         | Optional. Name of a `date` field that **delays** the completion bell until that date arrives (instead of firing on create). Requires `completionField` / `completionDoneValues` (the bell still clears via the done value). Must name a real `date` field. See "Time-gated bells" below.                                                                                                                                                                                                                                                                                           |
@@ -149,7 +149,7 @@ skipped, never crashes the host):
 
 `string` · `text` (multi-line) · `email` · `number` · `date` (`YYYY-MM-DD`) ·
 `datetime` (`YYYY-MM-DDTHH:MM`) · `boolean` · `markdown` · `money` · `enum` ·
-`ref` · `embed` · `backlinks` · `rollup` · `table` · `derived` · `image` · `file` · `toggle`
+`ref` · `embed` · `backlinks` · `rollup` · `table` · `derived` · `image` · `file` · `toggle` · `flag`
 
 Every field spec needs a `type` and a `label`. Extra keys by type:
 
@@ -249,6 +249,20 @@ Every field spec needs a `type` and a `label`. Extra keys by type:
   "done" checkbox. Without it, `status` only shows as a dropdown and a kanban
   column, with no checkbox to tick. `offValue` is the status to return to on
   uncheck (the default open column, e.g. `"Todo"`).
+- **`flag`** — `where: [<conditions>]`. A **computed boolean**: true when the
+  record matches every condition (AND). **Never stored** (like `derived`); the
+  host recomputes it on every read, so you NEVER write flag values into the
+  JSON. Each condition is `{ "field": "<field>", "op": "<op>", "value": "..." }`
+  with ops `eq` / `ne` / `in` (array value) / `contains` / `gt` / `gte` / `lt` /
+  `lte`, or `{ ..., "valueFrom": { "field": "<sibling>" } }` to compare two
+  fields of the same record (`spent > budget`). Condition fields must name
+  declared fields; cross-record `valueFrom.record` is not allowed. A flag may
+  read `derived` / `rollup` values, and other flags via their stringified
+  boolean (`{ "field": "isDone", "op": "eq", "value": "true" }`). Use it for
+  generic state summaries — done-ness, pass/fail, qualification:
+  `{ "type": "flag", "label": "Passed", "where": [{ "field": "score", "op": "gte", "value": "60" }] }`.
+  A flag can also drive completion tracking (stored-field conditions only) —
+  see `completionField` above and the "Completion tracking" section below.
 
 ### Conditional field visibility (`when`)
 
@@ -474,6 +488,16 @@ with any field type whose stringified value is comparable (`enum`, `string`,
 ["paid", "void"]` on an invoice, or `completionField: "shipped"` +
 `completionDoneValues: ["true"]` on an order.
 
+**Flag-form alternative**: `completionField` may instead name a **`flag`
+field** — then done ⇔ the flag's `where` matches, and `completionDoneValues`
+must be **omitted** (declaring it fails validation). Use it when done-ness is
+richer than one field's membership (e.g. `"isDone": { "type": "flag", "where":
+[{ "field": "score", "op": "gte", "value": "60" }] }` + `"completionField":
+"isDone"`). Two extra rules apply only to a completion flag: its `where` may
+reference **stored fields only** (no derived/rollup/toggle/flag/embed/backlinks
+— completion is checked against the raw record), and combining it with `spawn`
+requires an explicit `spawn.when`.
+
 Set `displayField` to make the bell title readable: with `displayField:
 "title"` the notification reads `Todos: Buy milk` instead of `Todos: t-0042`.
 It must name a real field; an empty value on a given record falls back to the
@@ -854,6 +878,13 @@ records through **`manageCollection`**, not raw file I/O:
   / `fields` on large collections to keep the result small — e.g.
   `fields: ["id"]` to check for an id collision before an add.
 - **Delete** — remove the record file (`manageCollection` has no delete).
+- **Aggregate — `queryItems`.** Counts, sums, averages, group-bys on ANY
+  collection via a structured query (`groupBy` / `aggregates` / `where` /
+  `orderBy` / `limit` — full shape in the "External data (CSV) collections"
+  section below). On file-backed collections it aggregates the ENRICHED
+  records, so computed fields (`derived` / `rollup` / `toggle`) are
+  queryable columns — "sum of invoice totals" works even when `total` is a
+  formula. Prefer it over doing arithmetic on `getItems` output.
 - **Cross-collection questions — `getOntology`.** Returns every collection in
   the workspace with its `primaryKey`, effective `displayField`, record count,
   and its `ref` / `embed` / `backlinks` / `rollup` relations (field → related slug, including refs
@@ -961,10 +992,11 @@ Semantics to remember (and to tell the user):
   logged). Fine for browsing — but NEVER compute an aggregate from
   `getItems` output on a large file (a capped scan gives a silently wrong
   number). Use `queryItems` instead.
-- **Aggregation — `manageCollection` `queryItems`** (dataSource collections
-  only): a structured query over the WHOLE file (uncapped scan, DuckDB
-  underneath). Answer counts / sums / averages / group-bys with it —
-  don't shell out to python/pandas for questions it covers. Shape:
+- **Aggregation — `manageCollection` `queryItems`**: a structured query over
+  the WHOLE file (uncapped scan, DuckDB underneath). Answer counts / sums /
+  averages / group-bys with it — don't shell out to python/pandas for
+  questions it covers. (It works on EVERY collection — see the Records
+  section; this bullet is about the dataSource specifics.) Shape:
 
   ```json
   {

package/assets/helps/custom-view.md

@@ -101,12 +101,14 @@ toggles, embeds) — the same numbers the user sees elsewhere.
   / shows one record at a time. Combinable with `fields`.
 - The primary key is always returned regardless of `fields`.
 
-### Aggregation queries (dataSource/CSV collections; `read` capability)
+### Aggregation queries (`read` capability)
 
-On a collection backed by an external CSV (`dataSource` in its schema), a
-view can run structured aggregations over the WHOLE file — the honest way
-to chart big data (the record read above is row-capped at 5,000; an
-aggregate computed from it would be silently wrong):
+A view can run structured aggregations over the collection — on a
+`dataSource` (CSV) collection this scans the WHOLE file (the record read
+above is row-capped at 5,000 there, so an aggregate computed from it would
+be silently wrong); on a file-backed collection it aggregates the ENRICHED
+records, so computed fields (`derived` / `rollup` / `toggle`) are queryable
+columns:
 
 ```js
 const res = await fetch(dataUrl + "/query", {
@@ -130,10 +132,12 @@ const { rows } = await res.json(); // [{ Category, total, n }, ...] — chart th
   `groupBy`/`aggregates`; `orderBy` sorts by a groupBy column or an
   aggregate alias; result rows clamp at 1,000 by default.
 - Structured JSON only — there is **no SQL surface**, by design.
-- A file-backed (non-dataSource) collection answers 400 ("file-backed") —
-  compute from the record read instead there.
-- Combine with `onChange` (below) to re-run the query when the CSV is
-  replaced — that's a live dashboard.
+- Combine with `onChange` (below) to stay live: in the callback, re-run
+  **this POST query** (wrap it in your own `refresh()` and register that)
+  — NOT the `?fields=` record read from the section above, which would
+  silently repaint an aggregation view with non-aggregated data. A
+  replaced CSV or edited records then redraw the chart — that's a live
+  dashboard.
 
 ### Writing records (only with the `write` capability)
 

package/assets/skills-preset/mc-zenn/SKILL.md

@@ -43,9 +43,11 @@ unless the user already told you:
 
 - **Clone an existing Zenn repo** (they already write Zenn on GitHub). Get the
   repo URL, then:
+
   ```bash
   git clone <url> github/zenn
   ```
+
   `npx zenn` fetches zenn-cli on demand, so a missing local dependency is fine.
 
 - **Create a fresh project** (standard zenn-cli flow):
@@ -90,6 +92,7 @@ fill it in. **A published slug becomes the article URL and can't change** — pi
 it deliberately.
 
 **Step 3 — write the frontmatter** (Zenn house style):
+
 ```yaml
 ---
 title: "<a clear title, in the user's language>"
@@ -99,6 +102,7 @@ topics: ["MulmoClaude", "<related>"]
 published: true
 ---
 ```
+
 - **Always include `MulmoClaude` in `topics`.** At most 5 topics, no spaces
   inside a single topic.
 - `type` defaults to `tech`; `published` defaults to `true` (use `false` when
@@ -109,6 +113,33 @@ implementation (fenced ` ```lang ` blocks, runnable commands) → result → a s
 wrap-up. Informative but casual; describe the work, not yourself. Put images in
 `github/zenn/images/` and reference them as `![alt](/images/<file>)`.
 
+Write it the way a person would, not the way a model defaults to. Each rule
+below comes from real reader feedback — ignore them and the draft reads as
+machine output:
+
+- **Sound human, not like a generated listicle.** Prefer flowing prose over
+  walls of bullets, use bold sparingly, and let paragraphs connect into an
+  argument. If every section is just a heading plus a list, vary the rhythm.
+- **No uncommon loanwords or jargon.** Use only terms a typical reader already
+  knows. Niche English acronyms, trendy katakana, and insider slang either get
+  dropped or replaced with plain words. A term the field itself hasn't settled
+  on ("code smell" and the like) is a red flag — say the plain thing instead
+  ("code that works now but bites you later").
+- **Define every term and acronym on first use**, in plain language, and put the
+  foundational ones up front — define "DRY" before the article leans on it. A
+  reader should never hit a word they can't parse.
+- **Carry a source's essence, don't just cite it.** When an idea comes from a
+  book or article, explain the idea itself in your own words; "see <book>"
+  teaches nothing. Search for the actual content when you're unsure what it says,
+  then write the substance.
+- **Make the article self-contained.** Anything project-specific — a repo's
+  internals, a config choice, a domain constraint — needs enough general
+  background that a reader with zero context can follow. Running longer is fine
+  when the extra length buys understanding.
+- **Match the stated audience.** "Explain to intermediate developers" means
+  patient explanations, concrete examples, real code from the work, and links —
+  not a terse summary.
+
 **Step 5 — save + preview.** Write `github/zenn/articles/<slug>.md`. Tell the
 user the path and how to preview: `cd github/zenn && npx zenn preview`
 (http://localhost:8000). Surface the title, slug, and topics.

package/dist/collection/core/completion.d.ts

@@ -0,0 +1,18 @@
+import { Where } from './where';
+/** The slice of a parsed schema the done predicate reads — minimal
+ *  structural shape (like `DerivableSchema`) so the client and server
+ *  `CollectionSchema` types both satisfy it as-is. */
+export interface CompletionSchemaView {
+    /** Optional so legacy-pair callers (and their test fixtures) that
+     *  never consult field specs keep working; only the flag form needs
+     *  to look the completion field up. */
+    fields?: Record<string, {
+        type: string;
+        where?: Where;
+    }>;
+    completionField?: string;
+    completionDoneValues?: readonly string[];
+}
+/** True iff the schema declares completion tracking AND `item` is done
+ *  under whichever completion form the schema uses (see module doc). */
+export declare function itemIsDone(schema: CompletionSchemaView, item: Record<string, unknown>): boolean;

package/dist/collection/core/deriveAll.d.ts

@@ -1,4 +1,5 @@
 import { FormulaContext } from './derivedFormula';
+import { Where } from './where';
 /** Minimal field shape the derive loop needs — accepts both the client
  *  FieldSpec and the server CollectionFieldSpec. */
 export interface DerivableFieldSpec {
@@ -7,6 +8,8 @@ export interface DerivableFieldSpec {
     to?: string;
     /** When type === "derived": formula evaluated against the record. */
     formula?: string;
+    /** When type === "flag": predicate matched against the record. */
+    where?: Where;
 }
 /** Minimal schema shape: just the ordered field map. */
 export interface DerivableSchema {
@@ -21,17 +24,19 @@ export type DeriveRefRecords = Record<string, Record<string, DerivableRecord>>;
  *  null when dangling / not loaded), keyed by the LOCAL field name —
  *  the shape `evaluateDerived` reads for `<field>.<col>` derefs. */
 export declare function resolveRowRefs(schema: DerivableSchema, record: DerivableRecord, refRecords: DeriveRefRecords): NonNullable<FormulaContext["refs"]>;
-/** Evaluate every `derived` field against `base`, saturating so a
- *  derived field can read another derived field computed in an earlier
- *  pass (`subtotal → tax → total` converges in ≤ field-count passes).
- *  Cycles can't loop forever — passes are bounded by the number of
- *  derived fields and the loop breaks as soon as a pass changes
- *  nothing. Failed formulas stay ABSENT (the UI renders them as
- *  em-dash). Returns a copy; `base` is never mutated.
+/** Evaluate every `derived` and `flag` field against `base`, saturating
+ *  so a computed field can read another one computed in an earlier pass
+ *  (`subtotal → tax → total` converges in ≤ field-count passes; a flag
+ *  may read a derived value, or another flag via its stringified
+ *  boolean). Cycles can't loop forever — passes are bounded by the
+ *  number of computed fields and the loop breaks as soon as a pass
+ *  changes nothing. Failed formulas stay ABSENT (the UI renders them as
+ *  em-dash); flags are total (always true/false). Returns a copy;
+ *  `base` is never mutated.
  *
- *  Derived keys already present in `base` are stripped before
+ *  Computed keys already present in `base` are stripped before
  *  evaluation: computed output is host-truth, never persisted-input
- *  fallback. A record JSON can carry a stale (or forged) derived value
+ *  fallback. A record JSON can carry a stale (or forged) computed value
  *  — raw Write/Edit, legacy data — and without the strip, a failing
  *  formula would silently surface that value as if the host computed
  *  it. */

package/dist/collection/core/schema.d.ts

@@ -52,10 +52,15 @@ export type CollectionFieldSpec = z.infer<typeof FieldSpecZ>;
  *  `derived` / display-only types (see `SubFieldSpecZ`). */
 export type CollectionSubFieldSpec = z.infer<typeof SubFieldSpecZ>;
 export type CollectionFieldType = CollectionFieldSpec["type"];
-/** derived/embed/backlinks/rollup/toggle are host-computed or projected —
- *  never written to the record JSON, so required / value checks and
- *  edit-draft slots must not apply to them. THE single source for
- *  "computed" — lives here (zod-free at runtime) so browser code
+/** The computed-boolean variant — a `where` predicate bound to a field
+ *  name; see `FlagFieldZ`. */
+export type CollectionFlagField = Extract<CollectionFieldSpec, {
+    type: "flag";
+}>;
+/** derived/embed/backlinks/rollup/toggle/flag are host-computed or
+ *  projected — never written to the record JSON, so required / value
+ *  checks and edit-draft slots must not apply to them. THE single source
+ *  for "computed" — lives here (zod-free at runtime) so browser code
  *  (`./draft`) and the zod record compiler (`./recordZ`, which re-exports
  *  it) share one set instead of drifting copies. */
 export declare const COMPUTED_TYPES: ReadonlySet<CollectionFieldType>;

package/dist/collection/core/schemaZ.d.ts

@@ -12,6 +12,46 @@ export declare const WhenZ: z.ZodObject<{
     field: z.ZodString;
     in: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+export declare const ValueRefZ: z.ZodObject<{
+    record: z.ZodOptional<z.ZodString>;
+    field: z.ZodString;
+}, z.core.$strip>;
+export declare const WhereCondZ: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        in: "in";
+        eq: "eq";
+        ne: "ne";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        contains: "contains";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    valueFrom: z.ZodOptional<z.ZodObject<{
+        record: z.ZodOptional<z.ZodString>;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const WhereZ: z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        in: "in";
+        eq: "eq";
+        ne: "ne";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        contains: "contains";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    valueFrom: z.ZodOptional<z.ZodObject<{
+        record: z.ZodOptional<z.ZodString>;
+        field: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
 export declare const SubFieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
     label: z.ZodString;
     required: z.ZodOptional<z.ZodBoolean>;
@@ -210,6 +250,33 @@ export declare const FieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
         in: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
     type: z.ZodLiteral<"toggle">;
+}, z.core.$strip>, z.ZodObject<{
+    where: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            in: "in";
+            eq: "eq";
+            ne: "ne";
+            gt: "gt";
+            gte: "gte";
+            lt: "lt";
+            lte: "lte";
+            contains: "contains";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        valueFrom: z.ZodOptional<z.ZodObject<{
+            record: z.ZodOptional<z.ZodString>;
+            field: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    label: z.ZodString;
+    primary: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    when: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        in: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"flag">;
 }, z.core.$strip>], "type">;
 /** A schema-declared record action, rendered as a button in the read-only
  *  detail view. Domain-free: the host validates the shape; the meaning
@@ -469,46 +536,6 @@ export declare const IngestZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
     role: z.ZodString;
     template: z.ZodString;
 }, z.core.$strip>], "kind">;
-export declare const ValueRefZ: z.ZodObject<{
-    record: z.ZodOptional<z.ZodString>;
-    field: z.ZodString;
-}, z.core.$strip>;
-export declare const WhereCondZ: z.ZodObject<{
-    field: z.ZodString;
-    op: z.ZodEnum<{
-        in: "in";
-        eq: "eq";
-        ne: "ne";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-        contains: "contains";
-    }>;
-    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    valueFrom: z.ZodOptional<z.ZodObject<{
-        record: z.ZodOptional<z.ZodString>;
-        field: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const WhereZ: z.ZodArray<z.ZodObject<{
-    field: z.ZodString;
-    op: z.ZodEnum<{
-        in: "in";
-        eq: "eq";
-        ne: "ne";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-        contains: "contains";
-    }>;
-    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    valueFrom: z.ZodOptional<z.ZodObject<{
-        record: z.ZodOptional<z.ZodString>;
-        field: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>>;
 export declare const DynamicIconSourceZ: z.ZodObject<{
     collection: z.ZodString;
     from: z.ZodOptional<z.ZodEnum<{
@@ -616,12 +643,12 @@ export declare const DynamicIconSpecZ: z.ZodObject<{
  *  workspace-relative and containment-checked exactly like `dataPath`. The
  *  row-id column is the schema's existing `primaryKey` — there is
  *  deliberately no second key concept here.
- *  See plans/feat-collection-csv-duckdb-source.md. */
+ *  See plans/done/feat-collection-csv-duckdb-source.md. */
 export declare const DataSourceZ: z.ZodObject<{
     type: z.ZodLiteral<"csv">;
     path: z.ZodString;
 }, z.core.$strip>;
-export declare const CollectionSchemaZ: z.ZodObject<{
+export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
     title: z.ZodString;
     icon: z.ZodString;
     dataPath: z.ZodOptional<z.ZodString>;
@@ -799,6 +826,33 @@ export declare const CollectionSchemaZ: z.ZodObject<{
             in: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
         type: z.ZodLiteral<"toggle">;
+    }, z.core.$strip>, z.ZodObject<{
+        where: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                in: "in";
+                eq: "eq";
+                ne: "ne";
+                gt: "gt";
+                gte: "gte";
+                lt: "lt";
+                lte: "lte";
+                contains: "contains";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+            valueFrom: z.ZodOptional<z.ZodObject<{
+                record: z.ZodOptional<z.ZodString>;
+                field: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        label: z.ZodString;
+        primary: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        when: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            in: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"flag">;
     }, z.core.$strip>], "type">>;
     actions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodString;
@@ -1053,4 +1107,4 @@ export declare const CollectionSchemaZ: z.ZodObject<{
         }, z.core.$strip>>;
         fallback: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+}, z.core.$strip>>;

package/dist/collection/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_promptSafety = require("../promptSafety-DRd15gQ6.cjs");
+const require_promptSafety = require("../promptSafety-DI_1Rvhk.cjs");
 const require_errorMessage = require("../errorMessage--LvXe_Jx.cjs");
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
@@ -483,6 +483,7 @@ exports.isSafeRecordId = require_promptSafety.isSafeRecordId;
 exports.isSafeSlug = require_promptSafety.isSafeSlug;
 exports.isSortableField = isSortableField;
 exports.itemIdOf = itemIdOf;
+exports.itemIsDone = require_promptSafety.itemIsDone;
 exports.itemLabelOf = itemLabelOf;
 exports.labelFieldFor = labelFieldFor;
 exports.matchesWhere = require_promptSafety.matchesWhere;