@mulmoclaude/core 0.22.1 → 0.23.1

package/assets/helps/collection-skills.md

@@ -126,7 +126,8 @@ skipped, never crashes the host):
 | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `title`                | Human name shown in the sidebar / header. Required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `icon`                 | A **Material Symbols** name (`receipt_long`, `people`, `schedule`, `menu_book`). Required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `dataPath`             | Workspace-relative records folder, e.g. `data/recipes/items`. Must stay under the workspace. Required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `dataPath`             | Workspace-relative records folder, e.g. `data/recipes/items`. Must stay under the workspace. Required — unless `dataSource` is set (declare exactly ONE of the two).                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `dataSource`           | Optional. `{ "type": "csv", "path": "data/students.csv" }` — the records ARE the rows of an external data file (workspace-relative, containment-checked like `dataPath`). Makes the collection **read-only** in every UI/tool write path; see "External data (CSV) collections" below. Mutually exclusive with `dataPath`, `singleton`, `ingest`, `spawn`, and `mutate` actions.                                                                                                                                                                                                     |
 | `primaryKey`           | The field name whose value is the filename. That field MUST set `primary: true`. The value must be a valid record id (see the **Records** section's id-charset rule). Required.                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -853,6 +854,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
@@ -905,6 +913,107 @@ directly:
   (This safety net applies after `putItems` batches too, but direct writes are
   where it earns its keep.)
 
+## External data (CSV) collections — `dataSource`
+
+When the user has a data file they want to "manage" / "visualize" / "見たい"
+(a student roster, an HR export, a product list — the BI use case), do NOT
+import the rows into record files. Define a collection **on top of** the file
+with `dataSource` — the file stays the single source of truth and the whole
+collection UI (table, kanban, calendar, custom views, remote views) works over
+its rows via the host's DuckDB-backed CSV store.
+
+**The schema-inference recipe** (user: "この CSV を管理したい" / "make this CSV a
+collection"):
+
+1. **Inspect the file** — Read the first ~30 lines. Note the header row
+   (column names), each column's apparent type, and which column uniquely
+   identifies a row.
+2. **Pick the key column** — set `primaryKey` to that column's name and flag
+   its field `primary: true`. Prefer an ID-ish column (student number, SKU,
+   email) over a name. Check for duplicates if unsure — duplicated key values
+   don't error, but the LAST row silently wins.
+   **Declare the key field as `type: "string"` even when the column is
+   numeric** (a row number, an integer ID): record ids are strings, and the
+   store overwrites the key field's value with the id — a `number`-typed key
+   would just hold a string anyway. Consequence to keep in mind: sorting by
+   the key column is lexicographic ("10" before "2"); if numeric ordering
+   matters to the user, sort by another column.
+3. **Declare `fields` matching the column names** — field name = CSV column
+   name, verbatim (Japanese column names are fine). Only declared fields
+   render as table columns; extra CSV columns still ride along in the record
+   detail. Use `number` / `date` / `enum` (when a column has a small closed
+   value set) / `string` for the rest — DuckDB sniffs the raw types, the
+   field spec controls rendering.
+4. **Set `displayField`** to the most human-readable column (a name). This
+   matters extra here: a key value that isn't a safe record id (Japanese
+   text, spaces) is hex-encoded into the record's address, and
+   `displayField` is what keeps lists and notifications readable.
+5. **Write the schema** with `dataSource` instead of `dataPath`, plus a
+   normal `SKILL.md`, under `data/skills/<slug>/` — same create flow as any
+   collection. In the SKILL body, point aggregation questions at
+   `manageCollection` `queryItems` (see below) — NOT at python/pandas and
+   NOT at `getItems`; SKILL.md text outlives help updates, so a wrong
+   steer here misroutes every future session on this collection.
+
+Semantics to remember (and to tell the user):
+
+- **Read-only** — no Add/Edit/Delete in the UI, `putItems` refuses, HTTP
+  writes answer 405. To change the data, **edit or replace the file itself**
+  (you can do that with the normal file tools when asked); open views refresh
+  automatically via a file watcher.
+- **Encoding** — Shift_JIS / CP932 and UTF-16 files work as-is; the host
+  decodes to a cache copy and never rewrites the user's file. Don't convert
+  the file to UTF-8 "to be safe" — an Excel re-export would just undo it.
+- **Row cap** — `getItems` / the UI list stops at 5,000 rows (a warn is
+  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`**: 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
+  {
+    "groupBy": ["Category"],
+    "aggregates": { "total": { "op": "sum", "column": "Price" }, "n": { "op": "count" } },
+    "where": [{ "field": "Availability", "op": "eq", "value": "in_stock" }],
+    "orderBy": [{ "field": "total", "dir": "desc" }],
+    "limit": 100
+  }
+  ```
+
+  Ops: `count` (column optional) / `sum` / `avg` / `min` / `max`; `where`
+  ops are the familiar `eq/ne/in/gt/gte/lt/lte/contains`; `orderBy` sorts
+  by a groupBy column or an aggregate alias; result rows are clamped
+  (default 1,000). At least one of `groupBy`/`aggregates` is required.
+  `sum`/`avg` skip non-numeric cells. A custom view can run the same
+  query shape via `POST <dataUrl>/query` with its read token — see
+  `config/helps/custom-view.md` — which is how dataSource dashboards
+  chart live data.
+- **Not registry material** — dataSource collections can't be imported from
+  or contributed to a registry (the data file is machine-local).
+
+Minimal example (Japanese roster, Shift_JIS file dropped at
+`data/students.csv`):
+
+```json
+{
+  "title": "生徒名簿",
+  "icon": "school",
+  "dataSource": { "type": "csv", "path": "data/students.csv" },
+  "primaryKey": "学籍番号",
+  "displayField": "氏名",
+  "fields": {
+    "学籍番号": { "type": "string", "label": "学籍番号", "primary": true },
+    "氏名": { "type": "string", "label": "氏名" },
+    "学年": { "type": "enum", "label": "学年", "values": ["1", "2", "3"] },
+    "入学日": { "type": "date", "label": "入学日" }
+  }
+}
+```
+
 ## End-to-end: creating a new collection skill
 
 1. Pick a `<slug>` (lowercase-hyphen, no `mc-` prefix) and a `dataPath`

package/assets/helps/custom-view.md

@@ -101,6 +101,44 @@ 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 (`read` capability)
+
+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", {
+  method: "POST",
+  headers: { Authorization: "Bearer " + token, "Content-Type": "application/json" },
+  body: JSON.stringify({
+    query: {
+      groupBy: ["Category"],
+      aggregates: { total: { op: "sum", column: "Price" }, n: { op: "count" } },
+      where: [{ field: "Availability", op: "eq", value: "in_stock" }],
+      orderBy: [{ field: "total", dir: "desc" }],
+      limit: 100,
+    },
+  }),
+});
+const { rows } = await res.json(); // [{ Category, total, n }, ...] — chart these
+```
+
+- Ops: `count` (column optional) / `sum` / `avg` / `min` / `max`; `where`
+  ops: `eq/ne/in/gt/gte/lt/lte/contains`; at least one of
+  `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.
+- 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)
 
 ```js

package/assets/helps/error-recovery.md

@@ -183,6 +183,36 @@ plugin via the `/skills` UI to refresh both the tgz and the ledger.
 A version skew on a peer dep means the plugin was built against an
 older host — bump the plugin via the Discover tab's update flow.
 
+## dataSource (CSV) collection reads fail — "DuckDB is unavailable on this host"
+
+A collection whose schema declares `dataSource` (external CSV) reads its rows
+through `@duckdb/node-api`, a NATIVE module with per-platform prebuilt
+bindings. When the binding is missing or fails to load, ONLY dataSource
+collections break (every file-backed collection keeps working) and reads
+fail with `DuckDB is unavailable on this host (@duckdb/node-api failed to
+load: …)`.
+
+Diagnosis + fixes, in order:
+
+1. **Reinstall dependencies** — `yarn install` at the app root. The usual
+   cause is an install that skipped the platform package
+   (`@duckdb/node-bindings-<platform>-<arch>`), e.g. after copying
+   `node_modules` between machines or architectures (an arm64 → x64 Docker
+   volume mount does exactly this).
+2. **Check the platform is supported** — `ls node_modules/@duckdb/ | cat`.
+   You should see a `node-bindings-<your platform>` package. If DuckDB ships
+   no prebuilt binding for the host (rare: musl/alpine, exotic arch), there
+   is no local fix — tell the user dataSource collections need a supported
+   platform (glibc Linux x64/arm64, macOS, Windows) and that their other
+   collections are unaffected.
+3. **Docker**: make sure the image installs dependencies INSIDE the
+   container (matching libc/arch) rather than bind-mounting a host
+   `node_modules`.
+
+Related, not an error: a dataSource CSV in Shift_JIS / UTF-16 is decoded
+automatically to a cache copy under the OS temp dir — never "fix" the
+user's file by re-encoding it.
+
 ## Fallback
 
 If none of the above matches the failing tool output:
@@ -308,6 +338,7 @@ shipped builders produce, and asserts `handlePermission` comes back over the MCP
 - **"multiple client_secret_*.json files found"**.
 - **"Google Calendar API: HTTP 403"** with a hint about enabling the API.
 - **"could not obtain a Google access token"** (grant revoked).
+- `calendarListCalendars` / non-primary calendar lookups fail with **HTTP 401/403 / insufficient scope**, or the list comes back empty even though the user has other calendars.
 
 ### Cause
 
@@ -328,6 +359,11 @@ Two ways the link can be minted, and the tool picks automatically:
 - **Not linked / grant revoked** — ask the user to link (or re-link) the account from this app's
   settings, then retry. Do NOT tell them to create a Google Cloud project, and do NOT try to
   create or edit the token file yourself.
+- **Calendar-list / non-primary lookup fails with insufficient scope (or lists nothing)** — the
+  account was linked before the calendar-list read scope (`calendar.calendarlist.readonly`) was
+  added, so the stored grant predates it. Ask the user to re-link from settings to add the scope,
+  then retry. Reading events on a non-primary calendar by id needs no re-link once the calendar
+  list is visible.
 - **Sign-in service unreachable / HTTP error** — the broker is down or the network is blocked.
   It is only needed to link and to renew an expired access token; ask the user to retry shortly.
   (A user with their own `~/.secrets/client_secret_*.json` never depends on it.)

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/queryZ.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+/** Hard ceiling on returned rows; `limit` clamps below it. A group-by on
+ *  a near-unique column would otherwise return one row per source row —
+ *  the exact materialization the aggregate path exists to avoid. */
+export declare const MAX_QUERY_ROWS = 10000;
+/** Default row cap when the query declares no `limit`. */
+export declare const DEFAULT_QUERY_ROWS = 1000;
+/** Cap on aggregate expressions per query — a record shape has no
+ *  intrinsic size limit, and thousands of expressions would make one
+ *  full-file scan arbitrarily wide. */
+export declare const MAX_QUERY_AGGREGATES = 32;
+/** One aggregate column: `count` (rows; `column` optional to count
+ *  non-null cells) or `sum`/`avg`/`min`/`max` over a named CSV column. */
+export declare const QueryAggregateZ: z.ZodObject<{
+    op: z.ZodEnum<{
+        sum: "sum";
+        count: "count";
+        avg: "avg";
+        min: "min";
+        max: "max";
+    }>;
+    column: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** One filter condition. Same op vocabulary as the schema-level `where`
+ *  (`core/where.ts`) so authors learn one set; values may be typed
+ *  (number / boolean) since CSV columns are. `in` requires an array
+ *  value, every other op a scalar. */
+export declare const QueryWhereZ: 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.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+}, z.core.$strip>;
+export declare const QueryOrderZ: z.ZodObject<{
+    field: z.ZodString;
+    dir: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>;
+/** The whole query. At least one of `groupBy` / `aggregates` must be
+ *  present: bare `groupBy` is a DISTINCT listing, bare `aggregates` a
+ *  whole-file scalar row, together a grouped aggregation. */
+export declare const CollectionQueryZ: z.ZodObject<{
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    aggregates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        op: z.ZodEnum<{
+            sum: "sum";
+            count: "count";
+            avg: "avg";
+            min: "min";
+            max: "max";
+        }>;
+        column: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    where: z.ZodOptional<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.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+    }, z.core.$strip>>>;
+    orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        dir: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strip>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CollectionQueryAggregate = z.infer<typeof QueryAggregateZ>;
+export type CollectionQueryWhere = z.infer<typeof QueryWhereZ>;
+export type CollectionQueryOrder = z.infer<typeof QueryOrderZ>;
+export type CollectionQuery = z.infer<typeof CollectionQueryZ>;

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ActionSpecZ, CollectionSchemaZ, CustomViewZ, DynamicIconRuleZ, DynamicIconSourceZ, DynamicIconSpecZ, EveryFieldDrivenZ, EveryLiteralZ, EveryZ, FieldSpecZ, IngestZ, SpawnZ, SubFieldSpecZ, WhenZ } from './schemaZ';
+import { ActionSpecZ, CollectionSchemaZ, CustomViewZ, DataSourceZ, DynamicIconRuleZ, DynamicIconSourceZ, DynamicIconSpecZ, EveryFieldDrivenZ, EveryLiteralZ, EveryZ, FieldSpecZ, IngestZ, SpawnZ, SubFieldSpecZ, WhenZ } from './schemaZ';
 /** Minimal "this collection is a feed" descriptor carried on the schema.
  *  Deliberately narrow — the canonical collection contract stays
  *  independent of the host's feeds subsystem. The host's richer retrieval
@@ -138,14 +138,27 @@ export type DynamicIconSpec = z.infer<typeof DynamicIconSpecZ>;
  *  union on `kind` (declarative retrievers | agent worker). The feeds
  *  subsystem's `IngestSpec` is the same union under its historical name. */
 export type CollectionIngestSpec = z.infer<typeof IngestZ>;
+/** The `dataSource` block: this collection's records are the rows of an
+ *  external read-only data file (v1: CSV). See `DataSourceZ`. */
+export type CollectionDataSource = z.infer<typeof DataSourceZ>;
 /** The whole `schema.json` contract. Key-level docs live on
  *  `CollectionSchemaZ` in `./schemaZ`. */
 export type CollectionSchema = z.infer<typeof CollectionSchemaZ>;
+/** True when `schema` declares an external `dataSource` — i.e. the
+ *  collection is READ-ONLY through every UI/tool write path (updates
+ *  happen by editing/replacing the data file itself). Isomorphic: both
+ *  the server write guards and the client's control hiding key off this
+ *  one predicate. */
+export declare function isReadOnlySchema(schema: Pick<CollectionSchema, "dataSource">): boolean;
 export interface CollectionSummary {
     slug: string;
     title: string;
     icon: string;
     source: CollectionSource;
+    /** Present (true) when the collection is backed by an external
+     *  `dataSource` and therefore read-only in every UI/tool write path.
+     *  Absent-when-writable, matching the other optional summary flags. */
+    readonly?: true;
     /** Slugs of the source collection(s) a `dynamicIcon` icon was computed
      *  from — present only when `schema.dynamicIcon` is set. Lets a client
      *  know which collection change-channel(s) to watch for a live icon

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

@@ -608,10 +608,27 @@ export declare const DynamicIconSpecZ: z.ZodObject<{
     }, z.core.$strip>>;
     fallback: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/** External-data collection: the records ARE the rows of a user-supplied
+ *  data file (v1: CSV), queried through DuckDB — never copied into
+ *  `<dataDir>/<id>.json` files. Declaring `dataSource` makes the collection
+ *  **read-only** in every UI/tool write path; updates happen by replacing /
+ *  editing the file itself (file-watch republishes the views). `path` is
+ *  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. */
+export declare const DataSourceZ: z.ZodObject<{
+    type: z.ZodLiteral<"csv">;
+    path: z.ZodString;
+}, z.core.$strip>;
 export declare const CollectionSchemaZ: z.ZodObject<{
     title: z.ZodString;
     icon: z.ZodString;
-    dataPath: z.ZodString;
+    dataPath: z.ZodOptional<z.ZodString>;
+    dataSource: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"csv">;
+        path: z.ZodString;
+    }, z.core.$strip>>;
     primaryKey: z.ZodString;
     singleton: z.ZodOptional<z.ZodString>;
     fields: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/collection/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_promptSafety = require("../promptSafety-DN5V__Ku.cjs");
+const require_promptSafety = require("../promptSafety-DRd15gQ6.cjs");
 const require_errorMessage = require("../errorMessage--LvXe_Jx.cjs");
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
@@ -38,7 +38,7 @@ var executePresentCollection = async (_context, args) => {
 		message: `Presented collection ${itemId ? `${collectionSlug} / ${itemId}` : collectionSlug}`,
 		data,
 		jsonData: data,
-		instructions: "The collection has been presented to the user as an interactive card. They can browse, open, edit, create, and delete records directly. No further action is needed unless they ask."
+		instructions: "The collection has been presented to the user as an interactive card. They can browse and open records directly; on a writable collection they can also edit, create, and delete (a read-only dataSource collection shows no edit controls — its records change by editing the backing data file). No further action is needed unless they ask."
 	};
 };
 //#endregion
@@ -478,6 +478,7 @@ exports.fieldVisible = require_promptSafety.fieldVisible;
 exports.firstDateField = require_promptSafety.firstDateField;
 exports.firstMissingRequiredField = firstMissingRequiredField;
 exports.isFieldDrivenEvery = require_promptSafety.isFieldDrivenEvery;
+exports.isReadOnlySchema = require_promptSafety.isReadOnlySchema;
 exports.isSafeRecordId = require_promptSafety.isSafeRecordId;
 exports.isSafeSlug = require_promptSafety.isSafeSlug;
 exports.isSortableField = isSortableField;