@mulmoclaude/core 0.23.0 → 0.24.0

package/dist/{server--FgDORd3.js → server-BpEo0FOd.js}

@@ -1,4 +1,4 @@
-import { B as isFieldDrivenEvery, C as backlinkRows, D as actionVisible, E as rollupValue, F as AGENT_INGEST_KIND, I as COMPUTED_TYPES, L as FEED_SCHEDULES, M as SAFE_SLUG_PATTERN, N as isSafeRecordId, P as isSafeSlug, R as INGEST_KINDS, T as projectBacklinkRow, V as isReadOnlySchema, b as resolveIcon, d as parseIsoDateTime, g as deriveAll, j as SAFE_RECORD_ID_PATTERN, t as defangForPrompt, u as parseIsoDate, w as coerceNumeric, x as selectDynamicRecord, y as firstDateField, z as embedTargetId } from "./promptSafety-rDWA9_JS.js";
+import { B as embedTargetId, D as rollupValue, E as projectBacklinkRow, F as isSafeSlug, H as isReadOnlySchema, I as AGENT_INGEST_KIND, L as COMPUTED_TYPES, M as SAFE_RECORD_ID_PATTERN, N as SAFE_SLUG_PATTERN, O as actionVisible, P as isSafeRecordId, R as FEED_SCHEDULES, S as itemIsDone, T as coerceNumeric, V as isFieldDrivenEvery, b as resolveIcon, d as parseIsoDateTime, g as deriveAll, t as defangForPrompt, u as parseIsoDate, w as backlinkRows, x as selectDynamicRecord, y as firstDateField, z as INGEST_KINDS } from "./promptSafety-BLUcImzd.js";
 import { isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath } from "./collection/paths.js";
 import { dataSkillDir, mirrorSkillWrite } from "./skill-bridge/index.js";
 import path from "node:path";
@@ -792,17 +792,18 @@ function whereFragment(cond) {
 		params: [cond.value]
 	};
 }
-/** Compile a validated query. Returns the SQL (whose FIRST placeholder is
-*  the CSV path — the executor binds it) and the where-value parameters
-*  that follow it. Callers MUST have run `CollectionQueryZ` first; this
-*  function trusts the shape (aliases already charset-checked, orderBy
-*  membership already enforced). */
-function compileCsvQuery(query, primaryKey) {
+/** Compile a validated query against `fromSql` (a table-function call
+*  whose FIRST placeholder is the source path — the executor binds it).
+*  Returns the SQL and the where-value parameters that follow the path.
+*  Callers MUST have run `CollectionQueryZ` first; this function trusts
+*  the shape (aliases already charset-checked, orderBy membership already
+*  enforced). */
+function compileQuery(query, fromSql) {
 	const groupBy = query.groupBy ?? [];
 	const aggregates = Object.entries(query.aggregates ?? {});
 	const selectList = [...groupBy.map(quoteIdent), ...aggregates.map(([alias, aggregate]) => `${aggregateExpr(aggregate)} AS ${quoteIdent(alias)}`)];
 	const where = (query.where ?? []).map(whereFragment);
-	const clauses = [`SELECT ${selectList.join(", ")}`, `FROM read_csv(${readCsvArgs(primaryKey)})`];
+	const clauses = [`SELECT ${selectList.join(", ")}`, `FROM ${fromSql}`];
 	if (where.length > 0) clauses.push(`WHERE ${where.map((fragment) => fragment.sql).join(" AND ")}`);
 	if (groupBy.length > 0) clauses.push(`GROUP BY ${groupBy.map(quoteIdent).join(", ")}`);
 	const orderBy = (query.orderBy ?? []).map((order) => quoteIdent(order.field) + (order.dir === "desc" ? " DESC" : " ASC"));
@@ -813,6 +814,21 @@ function compileCsvQuery(query, primaryKey) {
 		params: where.flatMap((fragment) => fragment.params)
 	};
 }
+/** Compile against a CSV file (the dataSource store's engine). */
+function compileCsvQuery(query, primaryKey) {
+	return compileQuery(query, `read_csv(${readCsvArgs(primaryKey)})`);
+}
+/** Compile against a JSONL file of ENRICHED records — the file-backed
+*  collections' engine (see `jsonlQuery.ts`). No VARCHAR key pin needed:
+*  enriched record ids are already strings. `sample_size=-1` makes the
+*  schema inference scan EVERY line — with the default sample, a sparse
+*  optional/derived field first appearing past the sample would not be
+*  inferred as a column and the query would binder-error on it (Codex P2
+*  on #2165). The full scan costs nothing extra here: aggregation reads
+*  the whole file anyway. */
+function compileJsonlQuery(query) {
+	return compileQuery(query, `read_json(?, format='newline_delimited', sample_size=-1)`);
+}
 //#endregion
 //#region src/collection/server/csvStore.ts
 /** `list()` row cap. Over-cap files are truncated with a warn — the v1
@@ -1133,6 +1149,74 @@ function storeFor(collection, opts = {}) {
 	};
 }
 //#endregion
+//#region src/collection/server/jsonlQuery.ts
+/** SQL semantics for an aggregate-only query over ZERO rows: one scalar
+*  row (`count` = 0, everything else NULL) — the same shape the CSV path
+*  produces for a header-only file, so callers reading `rows[0]` never
+*  break on storage kind or emptiness. A grouped query over zero rows is
+*  zero groups (`[]`), also matching SQL. Synthesized here because DuckDB
+*  has no empty file to infer a schema from. */
+function emptyCollectionResult(query) {
+	if ((query.groupBy?.length ?? 0) > 0) return [];
+	const aggregates = Object.entries(query.aggregates ?? {});
+	return [Object.fromEntries(aggregates.map(([alias, aggregate]) => [alias, aggregate.op === "count" ? 0 : null]))];
+}
+/** The SOURCE columns a query reads: groupBy columns, aggregate input
+*  columns, and where fields. (orderBy resolves to groupBy columns or
+*  aggregate ALIASES — never to a new source column — so it adds none.) */
+function referencedSourceColumns(query) {
+	const columns = new Set(query.groupBy ?? []);
+	for (const aggregate of Object.values(query.aggregates ?? {})) if (aggregate.column !== void 0) columns.add(aggregate.column);
+	for (const cond of query.where ?? []) columns.add(cond.field);
+	return [...columns];
+}
+/** Referenced columns that appear in NO row — a freshly-added optional
+*  field, or a derived field whose inputs no record has yet. DuckDB only
+*  infers columns from keys that occur in the JSONL, so without help a
+*  valid query on such a field binder-errors here while the CSV path
+*  (whose header always declares the column) returns NULLs. Padding the
+*  FIRST line with `col: null` makes the column exist (full-scan
+*  inference unions keys across lines) with matching NULL semantics. */
+function absentReferencedColumns(rows, query) {
+	const present = /* @__PURE__ */ new Set();
+	for (const row of rows) for (const key of Object.keys(row)) present.add(key);
+	return referencedSourceColumns(query).filter((column) => !present.has(column));
+}
+/** Run a validated query over enriched collection rows. */
+async function runQueryOverRows(rows, query) {
+	if (rows.length === 0) return emptyCollectionResult(query);
+	await mkdir(cacheDir(), {
+		recursive: true,
+		mode: 448
+	});
+	const jsonlPath = path.join(cacheDir(), `q-${randomBytes(8).toString("hex")}.jsonl`);
+	try {
+		const nullPads = Object.fromEntries(absentReferencedColumns(rows, query).map((column) => [column, null]));
+		const handle = await open(jsonlPath, "wx", 384);
+		try {
+			let first = true;
+			for (const row of rows) {
+				await handle.write(`${JSON.stringify(first ? {
+					...nullPads,
+					...row
+				} : row)}\n`);
+				first = false;
+			}
+		} finally {
+			await handle.close();
+		}
+		const { sql, params } = compileJsonlQuery(query);
+		return (await queryCsv(sql, [jsonlPath, ...params])).map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)])));
+	} finally {
+		await unlink(jsonlPath).catch((err) => {
+			if (err.code !== "ENOENT") log.warn("collections", "temp JSONL cleanup failed", {
+				path: jsonlPath,
+				error: String(err)
+			});
+		});
+	}
+}
+//#endregion
 //#region src/collection/core/recordZ.ts
 /** The emptiness rule shared by `required` and the "only check present
 *  values" gate. NOT a truthiness check — `0` and `false` are filled. */
@@ -1418,6 +1502,32 @@ var WhenZ = z.object({
 	field: z.string().trim().min(1),
 	in: z.array(z.string().trim().min(1)).min(1)
 });
+var ValueRefZ = z.object({
+	record: z.string().trim().min(1).optional(),
+	field: z.string().trim().min(1)
+});
+var WhereCondZ = z.object({
+	field: z.string().trim().min(1),
+	op: z.enum([
+		"eq",
+		"ne",
+		"in",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"contains"
+	]),
+	value: z.union([z.string(), z.array(z.string())]).optional(),
+	valueFrom: ValueRefZ.optional()
+}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
+	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
+	path: ["value"]
+}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
+	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
+	path: ["value"]
+});
+var WhereZ = z.array(WhereCondZ);
 var fieldBase = {
 	label: z.string().min(1),
 	primary: z.boolean().optional(),
@@ -1628,6 +1738,30 @@ var ToggleFieldZ = z.object({
 	onValue: z.string().trim().min(1),
 	offValue: z.string().trim().min(1)
 });
+/** A computed boolean: the record matched against a `where` predicate
+*  (the same AND-of-conditions shape `dynamicIcon` uses; evaluated by
+*  `./where`'s `matchesWhere`). Generic state summaries — isDone,
+*  isPassed, isQualified — become declared fields, so every
+*  field-driven mechanism (table cells, detail view, completion via
+*  `completionField`) picks them up without special cases. Never
+*  stored; computed by `deriveAll` on both server and client in the
+*  same saturation loop as `derived`, so a flag may read derived /
+*  rollup values — and other flags (`matchesWhere` stringifies, so
+*  `eq "true"` composes). Deliberately a STRUCTURED field, not formula
+*  syntax — the derived evaluator's no-string-literals boundary stays
+*  untouched (same reasoning as `rollup`). Cross-record
+*  `valueFrom.record` is rejected here: per-record evaluation has no
+*  `recordsById`, so it could only ever silently never-match.
+*  `where` condition fields are validated to exist by a schema-level
+*  refine below (a field can't see its siblings). */
+var FlagFieldZ = z.object({
+	type: z.literal("flag"),
+	...fieldBase,
+	where: WhereZ.min(1)
+}).refine((spec) => spec.where.every((cond) => cond.valueFrom?.record === void 0), {
+	message: "a flag's `where` cannot use `valueFrom.record` (cross-record references are unresolvable in per-record evaluation); use a literal `value` or a same-record `valueFrom` (field-to-field)",
+	path: ["where"]
+});
 var FieldSpecZ = z.discriminatedUnion("type", [
 	ScalarFieldZ,
 	RefFieldZ,
@@ -1638,7 +1772,8 @@ var FieldSpecZ = z.discriminatedUnion("type", [
 	EmbedFieldZ,
 	BacklinksFieldZ,
 	RollupFieldZ,
-	ToggleFieldZ
+	ToggleFieldZ,
+	FlagFieldZ
 ]);
 var actionBase = {
 	id: z.string().trim().min(1),
@@ -1787,32 +1922,6 @@ var AgentIngestZ = z.object({
 *  discovered from `<workspace>/feeds/` are REQUIRED to carry it (gated by
 *  `acceptParsedSchema`). */
 var IngestZ = z.discriminatedUnion("kind", [DeclarativeIngestZ, AgentIngestZ]);
-var ValueRefZ = z.object({
-	record: z.string().trim().min(1).optional(),
-	field: z.string().trim().min(1)
-});
-var WhereCondZ = z.object({
-	field: z.string().trim().min(1),
-	op: z.enum([
-		"eq",
-		"ne",
-		"in",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"contains"
-	]),
-	value: z.union([z.string(), z.array(z.string())]).optional(),
-	valueFrom: ValueRefZ.optional()
-}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
-	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
-	path: ["value"]
-}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
-	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
-	path: ["value"]
-});
-var WhereZ = z.array(WhereCondZ);
 var DynamicIconSourceZ = z.object({
 	collection: z.string().trim().min(1),
 	from: z.enum([
@@ -1907,12 +2016,12 @@ function fieldDrivenFromFieldCarried(schema) {
 *  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. */
 var DataSourceZ = z.object({
 	type: z.literal("csv"),
 	path: z.string().min(1)
 });
-var CollectionSchemaZ = z.object({
+var BareCollectionSchemaZ = z.object({
 	title: z.string().min(1),
 	icon: z.string().min(1),
 	dataPath: z.string().min(1).optional(),
@@ -1972,8 +2081,11 @@ var CollectionSchemaZ = z.object({
 }).refine((schema) => collectCurrencyFieldRefs(schema.fields).every((name) => CODE_FIELD_TYPES.has(schema.fields[name]?.type ?? "")), {
 	message: "a money field's `currencyField` must name a top-level `string`, `text`, or `enum` field that holds the currency code",
 	path: ["fields"]
-}).refine((schema) => schema.completionField === void 0 === (schema.completionDoneValues === void 0), {
-	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted)",
+}).refine((schema) => {
+	if (schema.completionField !== void 0 && schema.fields[schema.completionField]?.type === "flag") return schema.completionDoneValues === void 0;
+	return schema.completionField === void 0 === (schema.completionDoneValues === void 0);
+}, {
+	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted) — unless `completionField` names a `flag` field, in which case `completionDoneValues` must be omitted (done ⇔ the flag matches)",
 	path: ["completionField"]
 }).refine((schema) => schema.completionField === void 0 || schema.fields[schema.completionField] !== void 0, {
 	message: "schema `completionField` must name a top-level field declared in `fields`",
@@ -1984,6 +2096,22 @@ var CollectionSchemaZ = z.object({
 }).refine((schema) => Object.values(schema.fields).every((field) => field.when === void 0 || schema.fields[field.when.field] !== void 0), {
 	message: "a field's `when.field` must name a top-level field declared in `fields`",
 	path: ["fields"]
+}).refine((schema) => Object.values(schema.fields).every((field) => field.type !== "flag" || field.where.every((cond) => schema.fields[cond.field] !== void 0 && (cond.valueFrom === void 0 || schema.fields[cond.valueFrom.field] !== void 0))), {
+	message: "a flag field's `where` conditions must name top-level fields declared in `fields` (both `field` and a same-record `valueFrom.field`)",
+	path: ["fields"]
+}).refine((schema) => {
+	const spec = schema.completionField === void 0 ? void 0 : schema.fields[schema.completionField];
+	if (spec?.type !== "flag") return true;
+	return spec.where.every((cond) => [cond.field, ...cond.valueFrom ? [cond.valueFrom.field] : []].every((name) => {
+		const target = schema.fields[name];
+		return target !== void 0 && !COMPUTED_TYPES.has(target.type);
+	}));
+}, {
+	message: "a `flag` named by `completionField` may only reference STORED fields in its `where` — completion is evaluated against the raw record (before deriveAll), where computed values (derived/rollup/toggle/flag/embed/backlinks) are absent",
+	path: ["completionField"]
+}).refine((schema) => schema.spawn === void 0 || schema.spawn.when !== void 0 || schema.fields[schema.completionField ?? ""]?.type !== "flag", {
+	message: "a schema whose `completionField` names a `flag` field must declare an explicit `spawn.when` (the spawn-inert check cannot statically evaluate a flag's `where`)",
+	path: ["spawn"]
 }).refine((schema) => Object.values(schema.fields).every((field) => {
 	if (field.type !== "embed" || field.idField === void 0) return true;
 	const target = schema.fields[field.idField];
@@ -2058,6 +2186,46 @@ var CollectionSchemaZ = z.object({
 	message: "schema `views` must have unique `id`s",
 	path: ["views"]
 });
+var PROTOTYPE_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+/** The first own prototype-sensitive key of `value`, or null. */
+function ownPrototypeKey(value) {
+	if (value === null || typeof value !== "object") return null;
+	for (const key of PROTOTYPE_KEYS) if (Object.hasOwn(value, key)) return key;
+	return null;
+}
+/** Dotted path of the first prototype-sensitive field name in the raw
+*  schema input — top-level `fields`, each table field's `of`, and each
+*  action's `params` (the three records that DEFINE names) — or null. */
+function prototypeFieldKeyPath(input) {
+	if (input === null || typeof input !== "object") return null;
+	const schema = input;
+	const bad = ownPrototypeKey(schema.fields);
+	if (bad !== null) return `fields.${bad}`;
+	for (const [key, spec] of Object.entries(schema.fields ?? {})) {
+		const badSub = ownPrototypeKey(spec?.of);
+		if (badSub !== null) return `fields.${key}.of.${badSub}`;
+	}
+	for (const [listName, list] of [["actions", schema.actions], ["collectionActions", schema.collectionActions]]) for (const action of Array.isArray(list) ? list : []) {
+		const badParam = ownPrototypeKey(action?.params);
+		if (badParam !== null) return `${listName}.params.${badParam}`;
+	}
+	return null;
+}
+var CollectionSchemaZ = z.preprocess((input, ctx) => {
+	const bad = prototypeFieldKeyPath(input);
+	if (bad !== null) {
+		ctx.addIssue({
+			code: "custom",
+			message: `'${bad}': field names must not be prototype-sensitive keys (\`__proto__\`, \`constructor\`, \`prototype\`)`
+		});
+		return z.NEVER;
+	}
+	return input;
+}, BareCollectionSchemaZ);
 //#endregion
 //#region src/collection/server/discovery.ts
 function applyFeedSchemaDefaults(parsed, slug) {
@@ -2618,17 +2786,15 @@ function successorId(sourceId, next) {
 }
 /** True iff `item` satisfies the spawn predicate. With an explicit
 *  `when`, matches `String(item[when.field]) ∈ when.in`. Without one,
-*  defaults to the completion-done condition. Self-contained (no import
-*  from notifications.ts) to keep the module graph acyclic. */
+*  defaults to the completion-done condition — the shared, flag-aware
+*  `itemIsDone` (core/completion; downhill import, so the module graph
+*  stays acyclic). */
 function matchesWhen(when, schema, item) {
 	if (when) {
 		const raw = item[when.field];
 		return raw !== void 0 && raw !== null && when.in.includes(String(raw));
 	}
-	const { completionField, completionDoneValues } = schema;
-	if (!completionField || !completionDoneValues) return false;
-	const raw = item[completionField];
-	return raw !== void 0 && raw !== null && completionDoneValues.includes(String(raw));
+	return itemIsDone(schema, item);
 }
 /** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
 *  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
@@ -3173,17 +3339,27 @@ async function putOneItem(collection, record, mode, deps) {
 	if (result.kind === "conflict") return reject(itemId, `'${itemId}' already exists — mode "create" refuses overwrite; use "upsert" to update it`);
 	return reject(itemId, "write refused: the collection's data dir escapes the workspace");
 }
-/** Aggregation over a dataSource collection's WHOLE file via the
-*  structured query DSL (`core/queryZ.ts`) — the paved road for counts /
-*  sums / group-bys that `getItems` (row-capped, unaggregated) can't
-*  answer honestly. File-backed collections have no query engine yet:
-*  refuse with a pointer instead of silently emulating. */
+/** Aggregation over a collection via the structured query DSL
+*  (`core/queryZ.ts`) — the paved road for counts / sums / group-bys
+*  that a row listing can't answer honestly. Two engines behind one
+*  shape: a dataSource collection queries its CSV natively through the
+*  store (`store.query`, uncapped whole-file scan); a file-backed
+*  collection aggregates its ENRICHED records (computed fields —
+*  `derived` / `rollup` / `toggle` — are real columns) through the same
+*  compiled SQL over a temp JSONL (`runQueryOverRows`). */
 async function handleQueryItems(collection, queryArg, deps) {
-	const store = storeFor(collection, { workspaceRoot: deps.workspaceRoot });
-	if (!store.query) return `manageCollection: '${collection.slug}' is file-backed — queryItems currently supports only dataSource (CSV) collections; use getItems (with \`fields\`) instead.`;
 	const parsed = CollectionQueryZ.safeParse(queryArg);
 	if (!parsed.success) return `manageCollection: \`query\` rejected — fix and retry:\n${parsed.error.issues.slice(0, 20).map((issue) => `- ${issue.path.map(String).join(".") || "(root)"}: ${defangForPrompt(issue.message)}`).join("\n")}`;
-	const rows = await store.query(parsed.data);
+	const store = storeFor(collection, { workspaceRoot: deps.workspaceRoot });
+	if (store.query) {
+		const rows = await store.query(parsed.data);
+		return JSON.stringify({
+			collection: collection.slug,
+			count: rows.length,
+			rows
+		});
+	}
+	const rows = await runQueryOverRows(await enrichItems(collection, await store.list(), deps), parsed.data);
 	return JSON.stringify({
 		collection: collection.slug,
 		count: rows.length,
@@ -3313,7 +3489,7 @@ async function handlePutSchema(slug, schemaArg, deps) {
 		written: true
 	});
 }
-var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference, then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. On a dataSource (CSV) collection, answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` — it scans the WHOLE file, while getItems is row-capped, so an aggregate computed from getItems output can be silently wrong on large files.";
+var MANAGE_COLLECTION_PROMPT = "Use `manageCollection` instead of raw Read/Write/Edit when working with a collection's records OR its schema (raw file I/O stays available as the escape hatch). Before authoring or changing a collection's `schema.json`, call `schemaDocs` to load the field/DSL reference, then read with `getSchema` and write with `putSchema` — `putSchema` validates the whole schema before writing and returns actionable errors instead of silently failing discovery's validation. `getItems` is the only way to see computed values — `derived` fields (e.g. a portfolio's value), `toggle` projections, and `embed` records are host-computed and never present in the stored JSON files. On large collections pass `ids` and/or `fields` to keep the result small. For a question that spans collections (\"which clients have unpaid invoices?\"), start with `getOntology`: it lists every collection with its primaryKey, record count, and outbound `ref`/`embed` relations, so you know which collections to join before reading any records. `putItems` validates every row against the schema before writing (required fields, enum values, primaryKey = record id) and returns `{ written, rejected }`; fix each rejected row using its `problem` text and retry just those rows. Never include computed fields in a row you write. To update a few fields of an existing record, use `mode: \"merge\"` with a partial row ({ id, <changed fields> }) — the default upsert replaces the WHOLE record, so a partial upsert would silently erase every optional field it omits. Answer aggregation questions (counts, sums, averages, group-bys) with `queryItems` on ANY collection — on a dataSource (CSV) collection it scans the whole file (getItems is row-capped, so aggregates computed from its output can be silently wrong on large files); on a file-backed collection it aggregates the enriched records, so computed fields (derived/rollup/toggle) are queryable columns.";
 /** Validate getItems' optional `ids`/`fields` args, then delegate. */
 async function dispatchGetItems(collection, args, deps) {
 	const ids = optionalStringArray(args.ids, "ids");
@@ -3396,7 +3572,7 @@ var MANAGE_COLLECTION_DEFINITION = {
 			},
 			query: {
 				type: "object",
-				description: "queryItems (dataSource/CSV collections only): a structured aggregation query over the WHOLE file — `{ groupBy?: [\"col\"], aggregates?: { alias: { op: \"count\"|\"sum\"|\"avg\"|\"min\"|\"max\", column? } }, where?: [{ field, op, value }], orderBy?: [{ field, dir? }], limit? }`. At least one of groupBy/aggregates. Runs uncapped over the full file (unlike getItems), so use it for counts / sums / group-bys on large CSVs."
+				description: "queryItems: a structured aggregation query — `{ groupBy?: [\"col\"], aggregates?: { alias: { op: \"count\"|\"sum\"|\"avg\"|\"min\"|\"max\", column? } }, where?: [{ field, op, value }], orderBy?: [{ field, dir? }], limit? }`. At least one of groupBy/aggregates. On a dataSource (CSV) collection it scans the WHOLE file uncapped (unlike getItems); on a file-backed collection it aggregates the ENRICHED records, so computed fields (derived/rollup/toggle) are queryable columns. Use it for counts / sums / averages / group-bys instead of arithmetic over getItems output."
 			}
 		},
 		required: ["action"]
@@ -3411,6 +3587,6 @@ function makeManageCollectionTool(deps = {}) {
 	};
 }
 //#endregion
-export { promptPathsFor as $, validateCollectionRecords as A, dedupeByRecordId as B, discoverCollections as C, CollectionSchemaZ as D, toSummary as E, readOnlyRefusal as F, DEFAULT_QUERY_ROWS as G, normalizeCsvValue as H, storeFor as I, buildCollectionActionSeedPrompt as J, MAX_QUERY_ROWS as K, MAX_CSV_ROWS as L, compileRecordZ as M, recordFieldProblem as N, applyMutateAction as O, collectionWritable as P, listItems as Q, csvRowToItem as R, acceptParsedSchema as S, toDetail as T, compileCsvQuery as U, encodeCsvRecordId as V, CollectionQueryZ as W, generateItemId as X, deleteItem as Y, isRegularFile as Z, errorMessage as _, getWorkspaceRoot as _t, deleteCollection as a, writeItem as at, buildWorkspaceOntology as b, setCollectionChangePublisher as bt, computeSuccessor as c, isContainedInRoot as ct, isTriggerDue as d, resolveDataDir as dt, readCustomViewHtml as et, maybeSpawnSuccessor as f, resolveTemplatePath as ft, ONE_SECOND_MS as g, configureCollectionHost as gt, successorId as h, collectionsRegistriesConfigPath as ht, deleteCustomView as i, resolveCreateItemId as it, validateRecordObject as j, firstMutateParamProblem as k, daysInMonth as l, isContainedInWorkspace as lt, resolveEvery as m, safeSlugName as mt, MAX_UNSELECTIVE_ITEMS as n, readItem as nt, deleteCollectionRefusalMessage as o, writeFileAtomic as ot, parseCivil as p, safeRecordId as pt, buildActionSeedPrompt as q, makeManageCollectionTool as r, readSkillTemplate as rt, advanceTriggerDate as s, SCHEMA_FILE$1 as st, MAX_SCHEMA_ISSUES as t, readCustomViewI18n as tt, formatCivil as u, itemFilePath as ut, computeCollectionIcon as v, log as vt, loadCollection as w, schemaRelations as x, enrichItems as y, publishCollectionChange as yt, decodeCsvRecordId as z };
+export { isRegularFile as $, validateCollectionRecords as A, decodeCsvRecordId as B, discoverCollections as C, CollectionSchemaZ as D, toSummary as E, collectionWritable as F, compileJsonlQuery as G, encodeCsvRecordId as H, readOnlyRefusal as I, MAX_QUERY_ROWS as J, CollectionQueryZ as K, storeFor as L, compileRecordZ as M, recordFieldProblem as N, applyMutateAction as O, runQueryOverRows as P, generateItemId as Q, MAX_CSV_ROWS as R, acceptParsedSchema as S, setCollectionChangePublisher as St, toDetail as T, normalizeCsvValue as U, dedupeByRecordId as V, compileCsvQuery as W, buildCollectionActionSeedPrompt as X, buildActionSeedPrompt as Y, deleteItem as Z, errorMessage as _, collectionsRegistriesConfigPath as _t, deleteCollection as a, readSkillTemplate as at, buildWorkspaceOntology as b, log as bt, computeSuccessor as c, writeFileAtomic as ct, isTriggerDue as d, isContainedInWorkspace as dt, listItems as et, maybeSpawnSuccessor as f, itemFilePath as ft, ONE_SECOND_MS as g, safeSlugName as gt, successorId as h, safeRecordId as ht, deleteCustomView as i, readItem as it, validateRecordObject as j, firstMutateParamProblem as k, daysInMonth as l, SCHEMA_FILE$1 as lt, resolveEvery as m, resolveTemplatePath as mt, MAX_UNSELECTIVE_ITEMS as n, readCustomViewHtml as nt, deleteCollectionRefusalMessage as o, resolveCreateItemId as ot, parseCivil as p, resolveDataDir as pt, DEFAULT_QUERY_ROWS as q, makeManageCollectionTool as r, readCustomViewI18n as rt, advanceTriggerDate as s, writeItem as st, MAX_SCHEMA_ISSUES as t, promptPathsFor as tt, formatCivil as u, isContainedInRoot as ut, computeCollectionIcon as v, configureCollectionHost as vt, loadCollection as w, schemaRelations as x, publishCollectionChange as xt, enrichItems as y, getWorkspaceRoot as yt, csvRowToItem as z };
 
-//# sourceMappingURL=server--FgDORd3.js.map
+//# sourceMappingURL=server-BpEo0FOd.js.map