@mulmoclaude/core 1.0.1 → 1.2.1

package/assets/helps/collection-skills.md

@@ -146,6 +146,7 @@ skipped, never crashes the host):
 | `calendarTimeField`    | Optional. Name of a string field holding a free-form time or time-range (`"14:00-17:00"`, `"17:00-"`, `"16:30"`) used to place records on the calendar's **day (time-allocation) view**. Consulted only when the date fields are date-only — a `datetime` anchor/end pair carries its own clock and takes precedence. Requires `calendarField`. See "Calendar view" below.                                                                                                                                                                                                         |
 | `kanbanField`          | Optional. Name of an `enum` field that groups records into columns on the **Kanban board** (one column per declared value). When unset, the Kanban toggle still appears if the schema has any `enum` field — the first one is used, switchable in-view. Set this to pin a specific group field. Must name a real `enum` field. See "Kanban view" below.                                                                                                                                                                                                                            |
 | `views`                | Optional. Custom (LLM-authored) HTML views: `[{ id, label, icon?, file, capabilities?, target? }]`. Each renders an HTML file under `views/*.html` in a sandboxed iframe over the records, for layouts the built-ins don't cover (year/quarter overview, Gantt, report). `capabilities` is `["read"]` (default) or `["read","write"]`. `target: "mobile"` makes it a **remote view** for the phone app (different runtime contract — **`config/helps/custom-view-remote.md`**). See "Custom views" below and **`config/helps/custom-view.md`** for the desktop authoring contract. |
+| `googleCalendar`       | Optional. `{ "calendarId": "primary", "map": { "<field>": "summary" } }` — the host mirrors one of the user's **Google calendars** into this collection on a schedule, **LLM-free**: no tool call, no tokens per sync. Reach for it whenever the user asks for a collection that syncs with Google Calendar — never an `ingest.kind: "agent"` worker or the `google` MCP tools, which spend an LLM turn per refresh doing what the host does for free. Needs `dataPath`. See "Google Calendar sync" below and **`config/helps/google-calendar-collection.md`**.                    |
 
 ### Field types
 
@@ -710,6 +711,33 @@ Reach for `ingest.kind: "agent"` (not a `manageAutomations` task) whenever the
 schedule belongs to one collection: it travels with the schema, dies with the
 collection, and needs no separate setup.
 
+### Google Calendar sync (`googleCalendar`)
+
+A collection opts into **Google Calendar sync** the same way a feed opts into
+retrieval — by declaring a block. Add `googleCalendar` and the host pulls the
+user's changed events on a schedule and writes them as records **without calling
+you**: no tool call, no tokens per sync.
+
+```json
+"googleCalendar": {
+  "calendarId": "primary",
+  "map": { "title": "summary", "on": "start", "until": "end" }
+}
+```
+
+This is the answer whenever the user asks for a collection that syncs with
+Google Calendar — **not** an `ingest.kind: "agent"` worker and **not** the
+`google` MCP calendar tools, both of which spend an LLM turn on every refresh to
+produce what the host produces for free. `map` reads _your_ field name → the
+Google event field (`summary`, `start`, `end`, `htmlLink`, `colorId`, `status`);
+at least one entry is required. Never map the `primaryKey` — it always holds the
+Google event id, which is what makes a re-sync update a record instead of
+duplicating it.
+
+The rest of the contract — finding a non-primary `calendarId`, how deletions
+propagate, and the first-run caveat — is
+**`config/helps/google-calendar-collection.md`**. Read it before authoring one.
+
 ### Calendar view
 
 Any collection that has at least one `date` (or `datetime`) field gains a

package/dist/artifacts/paths.cjs

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/artifacts/paths.ts
+var MAX_SLUG_LEN = 120;
+/** The workspace directory every artifact lives under (`<workspace>/artifacts`). */
+var ARTIFACTS_ROOT = "artifacts";
+/**
+* Lowercase-ASCII slug for a throwaway, timestamped artifact filename. Empty,
+* whitespace-only, and non-ASCII-only titles fall back to `fallback`. Capped at
+* 120 chars so a long LLM title can't blow the filesystem's NAME_MAX.
+*
+* Leading/trailing hyphens are stripped with a linear scan rather than a regex
+* like `/^-+|-+$/` — CodeQL flags the trailing-anchor form as polynomial
+* backtracking on the attacker-influenced (LLM-provided) title. Strip → cap →
+* strip so a cut at the 120-char boundary can't re-expose a trailing hyphen.
+*/
+function slugifyArtifact(title, fallback) {
+	if (!title) return fallback;
+	const collapsed = title.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+	let start = 0;
+	let end = collapsed.length;
+	while (start < end && collapsed[start] === "-") start += 1;
+	while (end > start && collapsed[end - 1] === "-") end -= 1;
+	if (end - start > MAX_SLUG_LEN) end = start + MAX_SLUG_LEN;
+	while (end > start && collapsed[end - 1] === "-") end -= 1;
+	return collapsed.slice(start, end) || fallback;
+}
+/** UTC `YYYY/MM` partition (matches the host's #764 artifact sharding). UTC —
+*  not local — so a workspace synced across timezones stays in one bucket. */
+function yearMonthUtc(now = /* @__PURE__ */ new Date()) {
+	return `${now.getUTCFullYear()}/${String(now.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+/**
+* FileOps-relative artifact path: `<dir>[/YYYY/MM]/<slug>-<epochMs><ext>`. The
+* `<epochMs>` suffix keeps freshly-built filenames collision-free without a
+* random component. This is what `files.artifacts.write` takes; prefix it with
+* `toWorkspaceArtifactPath` for the workspace-relative form shown to the LLM.
+*/
+function buildArtifactRelPath(params) {
+	const { dir, title, ext, fallback, now = /* @__PURE__ */ new Date(), partitioned = true } = params;
+	const fileName = `${slugifyArtifact(title, fallback)}-${now.getTime()}${ext}`;
+	return (partitioned ? [
+		dir,
+		yearMonthUtc(now),
+		fileName
+	] : [dir, fileName]).join("/");
+}
+/** Prefix a FileOps-relative artifact path with the workspace `artifacts/` root. */
+function toWorkspaceArtifactPath(relPath) {
+	return `${ARTIFACTS_ROOT}/${relPath}`;
+}
+/**
+* True when any `/`-segment of `value` is empty (`//`, leading/trailing slash),
+* `.`, or `..`. The lexical traversal / non-canonical guard every artifact path
+* check shares — equivalent to `path.posix.normalize(v) === v && !v.includes("..")`
+* — so a workspace-escape judgement can't drift between plugins.
+*/
+function hasUnsafePathSegment(value) {
+	return value.split("/").some((seg) => seg === "" || seg === "." || seg === "..");
+}
+//#endregion
+exports.ARTIFACTS_ROOT = ARTIFACTS_ROOT;
+exports.buildArtifactRelPath = buildArtifactRelPath;
+exports.hasUnsafePathSegment = hasUnsafePathSegment;
+exports.slugifyArtifact = slugifyArtifact;
+exports.toWorkspaceArtifactPath = toWorkspaceArtifactPath;
+exports.yearMonthUtc = yearMonthUtc;
+
+//# sourceMappingURL=paths.cjs.map

package/dist/artifacts/paths.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.cjs","names":[],"sources":["../../src/artifacts/paths.ts"],"sourcesContent":["// Shared artifact-path builders for the presentation plugins (chart / html /\n// mulmoscript). Browser-safe by design: no node:path / no node:crypto, so it\n// bundles into both the server core and the browser (`./vue`) plugin entries.\n//\n// These are POSIX artifact *wire paths* — stored in JSON and used as the\n// generic `files.artifacts` FileOps keys — so they must ALWAYS join with `/`\n// regardless of host OS. `path.join` would emit `\\` on Windows and corrupt\n// them; `path.posix.join` would drag in node:path and break the browser\n// bundle. So already-sanitised segments are joined with `/` directly (same\n// choice the plugins made before this module existed).\n\nconst MAX_SLUG_LEN = 120;\n\n/** The workspace directory every artifact lives under (`<workspace>/artifacts`). */\nexport const ARTIFACTS_ROOT = \"artifacts\";\n\n/**\n * Lowercase-ASCII slug for a throwaway, timestamped artifact filename. Empty,\n * whitespace-only, and non-ASCII-only titles fall back to `fallback`. Capped at\n * 120 chars so a long LLM title can't blow the filesystem's NAME_MAX.\n *\n * Leading/trailing hyphens are stripped with a linear scan rather than a regex\n * like `/^-+|-+$/` — CodeQL flags the trailing-anchor form as polynomial\n * backtracking on the attacker-influenced (LLM-provided) title. Strip → cap →\n * strip so a cut at the 120-char boundary can't re-expose a trailing hyphen.\n */\nexport function slugifyArtifact(title: string | undefined, fallback: string): string {\n  if (!title) return fallback;\n  const collapsed = title.toLowerCase().replace(/[^a-z0-9]+/g, \"-\");\n  let start = 0;\n  let end = collapsed.length;\n  while (start < end && collapsed[start] === \"-\") start += 1;\n  while (end > start && collapsed[end - 1] === \"-\") end -= 1;\n  if (end - start > MAX_SLUG_LEN) end = start + MAX_SLUG_LEN;\n  while (end > start && collapsed[end - 1] === \"-\") end -= 1;\n  return collapsed.slice(start, end) || fallback;\n}\n\n/** UTC `YYYY/MM` partition (matches the host's #764 artifact sharding). UTC —\n *  not local — so a workspace synced across timezones stays in one bucket. */\nexport function yearMonthUtc(now: Date = new Date()): string {\n  const year = now.getUTCFullYear();\n  const month = String(now.getUTCMonth() + 1).padStart(2, \"0\");\n  return `${year}/${month}`;\n}\n\nexport interface ArtifactRelPathParams {\n  /** Artifact-kind directory under the artifacts root (e.g. `charts`, `html`, `stories`). */\n  dir: string;\n  /** Human title the slug is derived from; empty/non-ASCII falls back to `fallback`. */\n  title: string | undefined;\n  /** File extension INCLUDING the leading dot (e.g. `.html`, `.chart.json`). */\n  ext: string;\n  /** Slug used when `title` yields nothing (e.g. `chart`, `page`, `story`). */\n  fallback: string;\n  now?: Date;\n  /** Include the `YYYY/MM` partition segment. Default true; stories opt out. */\n  partitioned?: boolean;\n}\n\n/**\n * FileOps-relative artifact path: `<dir>[/YYYY/MM]/<slug>-<epochMs><ext>`. The\n * `<epochMs>` suffix keeps freshly-built filenames collision-free without a\n * random component. This is what `files.artifacts.write` takes; prefix it with\n * `toWorkspaceArtifactPath` for the workspace-relative form shown to the LLM.\n */\nexport function buildArtifactRelPath(params: ArtifactRelPathParams): string {\n  const { dir, title, ext, fallback, now = new Date(), partitioned = true } = params;\n  const fileName = `${slugifyArtifact(title, fallback)}-${now.getTime()}${ext}`;\n  const segments = partitioned ? [dir, yearMonthUtc(now), fileName] : [dir, fileName];\n  return segments.join(\"/\");\n}\n\n/** Prefix a FileOps-relative artifact path with the workspace `artifacts/` root. */\nexport function toWorkspaceArtifactPath(relPath: string): string {\n  return `${ARTIFACTS_ROOT}/${relPath}`;\n}\n\n/**\n * True when any `/`-segment of `value` is empty (`//`, leading/trailing slash),\n * `.`, or `..`. The lexical traversal / non-canonical guard every artifact path\n * check shares — equivalent to `path.posix.normalize(v) === v && !v.includes(\"..\")`\n * — so a workspace-escape judgement can't drift between plugins.\n */\nexport function hasUnsafePathSegment(value: string): boolean {\n  return value.split(\"/\").some((seg) => seg === \"\" || seg === \".\" || seg === \"..\");\n}\n"],"mappings":";;AAWA,IAAM,eAAe;;AAGrB,IAAa,iBAAiB;;;;;;;;;;;AAY9B,SAAgB,gBAAgB,OAA2B,UAA0B;CACnF,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,YAAY,MAAM,YAAY,CAAC,CAAC,QAAQ,eAAe,GAAG;CAChE,IAAI,QAAQ;CACZ,IAAI,MAAM,UAAU;CACpB,OAAO,QAAQ,OAAO,UAAU,WAAW,KAAK,SAAS;CACzD,OAAO,MAAM,SAAS,UAAU,MAAM,OAAO,KAAK,OAAO;CACzD,IAAI,MAAM,QAAQ,cAAc,MAAM,QAAQ;CAC9C,OAAO,MAAM,SAAS,UAAU,MAAM,OAAO,KAAK,OAAO;CACzD,OAAO,UAAU,MAAM,OAAO,GAAG,KAAK;AACxC;;;AAIA,SAAgB,aAAa,sBAAY,IAAI,KAAK,GAAW;CAG3D,OAAO,GAFM,IAAI,eAEP,EAAK,GADD,OAAO,IAAI,YAAY,IAAI,CAAC,CAAC,CAAC,SAAS,GAAG,GACtC;AACpB;;;;;;;AAsBA,SAAgB,qBAAqB,QAAuC;CAC1E,MAAM,EAAE,KAAK,OAAO,KAAK,UAAU,sBAAM,IAAI,KAAK,GAAG,cAAc,SAAS;CAC5E,MAAM,WAAW,GAAG,gBAAgB,OAAO,QAAQ,EAAE,GAAG,IAAI,QAAQ,IAAI;CAExE,QADiB,cAAc;EAAC;EAAK,aAAa,GAAG;EAAG;CAAQ,IAAI,CAAC,KAAK,QAAQ,EAAA,CAClE,KAAK,GAAG;AAC1B;;AAGA,SAAgB,wBAAwB,SAAyB;CAC/D,OAAO,GAAG,eAAe,GAAG;AAC9B;;;;;;;AAQA,SAAgB,qBAAqB,OAAwB;CAC3D,OAAO,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,QAAQ,MAAM,QAAQ,OAAO,QAAQ,IAAI;AACjF"}

package/dist/artifacts/paths.d.ts

@@ -0,0 +1,45 @@
+/** The workspace directory every artifact lives under (`<workspace>/artifacts`). */
+export declare const ARTIFACTS_ROOT = "artifacts";
+/**
+ * Lowercase-ASCII slug for a throwaway, timestamped artifact filename. Empty,
+ * whitespace-only, and non-ASCII-only titles fall back to `fallback`. Capped at
+ * 120 chars so a long LLM title can't blow the filesystem's NAME_MAX.
+ *
+ * Leading/trailing hyphens are stripped with a linear scan rather than a regex
+ * like `/^-+|-+$/` — CodeQL flags the trailing-anchor form as polynomial
+ * backtracking on the attacker-influenced (LLM-provided) title. Strip → cap →
+ * strip so a cut at the 120-char boundary can't re-expose a trailing hyphen.
+ */
+export declare function slugifyArtifact(title: string | undefined, fallback: string): string;
+/** UTC `YYYY/MM` partition (matches the host's #764 artifact sharding). UTC —
+ *  not local — so a workspace synced across timezones stays in one bucket. */
+export declare function yearMonthUtc(now?: Date): string;
+export interface ArtifactRelPathParams {
+    /** Artifact-kind directory under the artifacts root (e.g. `charts`, `html`, `stories`). */
+    dir: string;
+    /** Human title the slug is derived from; empty/non-ASCII falls back to `fallback`. */
+    title: string | undefined;
+    /** File extension INCLUDING the leading dot (e.g. `.html`, `.chart.json`). */
+    ext: string;
+    /** Slug used when `title` yields nothing (e.g. `chart`, `page`, `story`). */
+    fallback: string;
+    now?: Date;
+    /** Include the `YYYY/MM` partition segment. Default true; stories opt out. */
+    partitioned?: boolean;
+}
+/**
+ * FileOps-relative artifact path: `<dir>[/YYYY/MM]/<slug>-<epochMs><ext>`. The
+ * `<epochMs>` suffix keeps freshly-built filenames collision-free without a
+ * random component. This is what `files.artifacts.write` takes; prefix it with
+ * `toWorkspaceArtifactPath` for the workspace-relative form shown to the LLM.
+ */
+export declare function buildArtifactRelPath(params: ArtifactRelPathParams): string;
+/** Prefix a FileOps-relative artifact path with the workspace `artifacts/` root. */
+export declare function toWorkspaceArtifactPath(relPath: string): string;
+/**
+ * True when any `/`-segment of `value` is empty (`//`, leading/trailing slash),
+ * `.`, or `..`. The lexical traversal / non-canonical guard every artifact path
+ * check shares — equivalent to `path.posix.normalize(v) === v && !v.includes("..")`
+ * — so a workspace-escape judgement can't drift between plugins.
+ */
+export declare function hasUnsafePathSegment(value: string): boolean;

package/dist/artifacts/paths.js

@@ -0,0 +1,62 @@
+//#region src/artifacts/paths.ts
+var MAX_SLUG_LEN = 120;
+/** The workspace directory every artifact lives under (`<workspace>/artifacts`). */
+var ARTIFACTS_ROOT = "artifacts";
+/**
+* Lowercase-ASCII slug for a throwaway, timestamped artifact filename. Empty,
+* whitespace-only, and non-ASCII-only titles fall back to `fallback`. Capped at
+* 120 chars so a long LLM title can't blow the filesystem's NAME_MAX.
+*
+* Leading/trailing hyphens are stripped with a linear scan rather than a regex
+* like `/^-+|-+$/` — CodeQL flags the trailing-anchor form as polynomial
+* backtracking on the attacker-influenced (LLM-provided) title. Strip → cap →
+* strip so a cut at the 120-char boundary can't re-expose a trailing hyphen.
+*/
+function slugifyArtifact(title, fallback) {
+	if (!title) return fallback;
+	const collapsed = title.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+	let start = 0;
+	let end = collapsed.length;
+	while (start < end && collapsed[start] === "-") start += 1;
+	while (end > start && collapsed[end - 1] === "-") end -= 1;
+	if (end - start > MAX_SLUG_LEN) end = start + MAX_SLUG_LEN;
+	while (end > start && collapsed[end - 1] === "-") end -= 1;
+	return collapsed.slice(start, end) || fallback;
+}
+/** UTC `YYYY/MM` partition (matches the host's #764 artifact sharding). UTC —
+*  not local — so a workspace synced across timezones stays in one bucket. */
+function yearMonthUtc(now = /* @__PURE__ */ new Date()) {
+	return `${now.getUTCFullYear()}/${String(now.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+/**
+* FileOps-relative artifact path: `<dir>[/YYYY/MM]/<slug>-<epochMs><ext>`. The
+* `<epochMs>` suffix keeps freshly-built filenames collision-free without a
+* random component. This is what `files.artifacts.write` takes; prefix it with
+* `toWorkspaceArtifactPath` for the workspace-relative form shown to the LLM.
+*/
+function buildArtifactRelPath(params) {
+	const { dir, title, ext, fallback, now = /* @__PURE__ */ new Date(), partitioned = true } = params;
+	const fileName = `${slugifyArtifact(title, fallback)}-${now.getTime()}${ext}`;
+	return (partitioned ? [
+		dir,
+		yearMonthUtc(now),
+		fileName
+	] : [dir, fileName]).join("/");
+}
+/** Prefix a FileOps-relative artifact path with the workspace `artifacts/` root. */
+function toWorkspaceArtifactPath(relPath) {
+	return `${ARTIFACTS_ROOT}/${relPath}`;
+}
+/**
+* True when any `/`-segment of `value` is empty (`//`, leading/trailing slash),
+* `.`, or `..`. The lexical traversal / non-canonical guard every artifact path
+* check shares — equivalent to `path.posix.normalize(v) === v && !v.includes("..")`
+* — so a workspace-escape judgement can't drift between plugins.
+*/
+function hasUnsafePathSegment(value) {
+	return value.split("/").some((seg) => seg === "" || seg === "." || seg === "..");
+}
+//#endregion
+export { ARTIFACTS_ROOT, buildArtifactRelPath, hasUnsafePathSegment, slugifyArtifact, toWorkspaceArtifactPath, yearMonthUtc };
+
+//# sourceMappingURL=paths.js.map

package/dist/artifacts/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","names":[],"sources":["../../src/artifacts/paths.ts"],"sourcesContent":["// Shared artifact-path builders for the presentation plugins (chart / html /\n// mulmoscript). Browser-safe by design: no node:path / no node:crypto, so it\n// bundles into both the server core and the browser (`./vue`) plugin entries.\n//\n// These are POSIX artifact *wire paths* — stored in JSON and used as the\n// generic `files.artifacts` FileOps keys — so they must ALWAYS join with `/`\n// regardless of host OS. `path.join` would emit `\\` on Windows and corrupt\n// them; `path.posix.join` would drag in node:path and break the browser\n// bundle. So already-sanitised segments are joined with `/` directly (same\n// choice the plugins made before this module existed).\n\nconst MAX_SLUG_LEN = 120;\n\n/** The workspace directory every artifact lives under (`<workspace>/artifacts`). */\nexport const ARTIFACTS_ROOT = \"artifacts\";\n\n/**\n * Lowercase-ASCII slug for a throwaway, timestamped artifact filename. Empty,\n * whitespace-only, and non-ASCII-only titles fall back to `fallback`. Capped at\n * 120 chars so a long LLM title can't blow the filesystem's NAME_MAX.\n *\n * Leading/trailing hyphens are stripped with a linear scan rather than a regex\n * like `/^-+|-+$/` — CodeQL flags the trailing-anchor form as polynomial\n * backtracking on the attacker-influenced (LLM-provided) title. Strip → cap →\n * strip so a cut at the 120-char boundary can't re-expose a trailing hyphen.\n */\nexport function slugifyArtifact(title: string | undefined, fallback: string): string {\n  if (!title) return fallback;\n  const collapsed = title.toLowerCase().replace(/[^a-z0-9]+/g, \"-\");\n  let start = 0;\n  let end = collapsed.length;\n  while (start < end && collapsed[start] === \"-\") start += 1;\n  while (end > start && collapsed[end - 1] === \"-\") end -= 1;\n  if (end - start > MAX_SLUG_LEN) end = start + MAX_SLUG_LEN;\n  while (end > start && collapsed[end - 1] === \"-\") end -= 1;\n  return collapsed.slice(start, end) || fallback;\n}\n\n/** UTC `YYYY/MM` partition (matches the host's #764 artifact sharding). UTC —\n *  not local — so a workspace synced across timezones stays in one bucket. */\nexport function yearMonthUtc(now: Date = new Date()): string {\n  const year = now.getUTCFullYear();\n  const month = String(now.getUTCMonth() + 1).padStart(2, \"0\");\n  return `${year}/${month}`;\n}\n\nexport interface ArtifactRelPathParams {\n  /** Artifact-kind directory under the artifacts root (e.g. `charts`, `html`, `stories`). */\n  dir: string;\n  /** Human title the slug is derived from; empty/non-ASCII falls back to `fallback`. */\n  title: string | undefined;\n  /** File extension INCLUDING the leading dot (e.g. `.html`, `.chart.json`). */\n  ext: string;\n  /** Slug used when `title` yields nothing (e.g. `chart`, `page`, `story`). */\n  fallback: string;\n  now?: Date;\n  /** Include the `YYYY/MM` partition segment. Default true; stories opt out. */\n  partitioned?: boolean;\n}\n\n/**\n * FileOps-relative artifact path: `<dir>[/YYYY/MM]/<slug>-<epochMs><ext>`. The\n * `<epochMs>` suffix keeps freshly-built filenames collision-free without a\n * random component. This is what `files.artifacts.write` takes; prefix it with\n * `toWorkspaceArtifactPath` for the workspace-relative form shown to the LLM.\n */\nexport function buildArtifactRelPath(params: ArtifactRelPathParams): string {\n  const { dir, title, ext, fallback, now = new Date(), partitioned = true } = params;\n  const fileName = `${slugifyArtifact(title, fallback)}-${now.getTime()}${ext}`;\n  const segments = partitioned ? [dir, yearMonthUtc(now), fileName] : [dir, fileName];\n  return segments.join(\"/\");\n}\n\n/** Prefix a FileOps-relative artifact path with the workspace `artifacts/` root. */\nexport function toWorkspaceArtifactPath(relPath: string): string {\n  return `${ARTIFACTS_ROOT}/${relPath}`;\n}\n\n/**\n * True when any `/`-segment of `value` is empty (`//`, leading/trailing slash),\n * `.`, or `..`. The lexical traversal / non-canonical guard every artifact path\n * check shares — equivalent to `path.posix.normalize(v) === v && !v.includes(\"..\")`\n * — so a workspace-escape judgement can't drift between plugins.\n */\nexport function hasUnsafePathSegment(value: string): boolean {\n  return value.split(\"/\").some((seg) => seg === \"\" || seg === \".\" || seg === \"..\");\n}\n"],"mappings":";AAWA,IAAM,eAAe;;AAGrB,IAAa,iBAAiB;;;;;;;;;;;AAY9B,SAAgB,gBAAgB,OAA2B,UAA0B;CACnF,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,YAAY,MAAM,YAAY,CAAC,CAAC,QAAQ,eAAe,GAAG;CAChE,IAAI,QAAQ;CACZ,IAAI,MAAM,UAAU;CACpB,OAAO,QAAQ,OAAO,UAAU,WAAW,KAAK,SAAS;CACzD,OAAO,MAAM,SAAS,UAAU,MAAM,OAAO,KAAK,OAAO;CACzD,IAAI,MAAM,QAAQ,cAAc,MAAM,QAAQ;CAC9C,OAAO,MAAM,SAAS,UAAU,MAAM,OAAO,KAAK,OAAO;CACzD,OAAO,UAAU,MAAM,OAAO,GAAG,KAAK;AACxC;;;AAIA,SAAgB,aAAa,sBAAY,IAAI,KAAK,GAAW;CAG3D,OAAO,GAFM,IAAI,eAEP,EAAK,GADD,OAAO,IAAI,YAAY,IAAI,CAAC,CAAC,CAAC,SAAS,GAAG,GACtC;AACpB;;;;;;;AAsBA,SAAgB,qBAAqB,QAAuC;CAC1E,MAAM,EAAE,KAAK,OAAO,KAAK,UAAU,sBAAM,IAAI,KAAK,GAAG,cAAc,SAAS;CAC5E,MAAM,WAAW,GAAG,gBAAgB,OAAO,QAAQ,EAAE,GAAG,IAAI,QAAQ,IAAI;CAExE,QADiB,cAAc;EAAC;EAAK,aAAa,GAAG;EAAG;CAAQ,IAAI,CAAC,KAAK,QAAQ,EAAA,CAClE,KAAK,GAAG;AAC1B;;AAGA,SAAgB,wBAAwB,SAAyB;CAC/D,OAAO,GAAG,eAAe,GAAG;AAC9B;;;;;;;AAQA,SAAgB,qBAAqB,OAAwB;CAC3D,OAAO,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,QAAQ,MAAM,QAAQ,OAAO,QAAQ,IAAI;AACjF"}

package/dist/atomic-C_7YpMiM.cjs

@@ -0,0 +1,102 @@
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_crypto = require("node:crypto");
+//#region src/files/atomic.ts
+var DEFAULT_UNIQUE_TMP = true;
+function tmpPathFor(filePath, uniqueTmp) {
+	return uniqueTmp ?? DEFAULT_UNIQUE_TMP ? `${filePath}.${(0, node_crypto.randomBytes)(6).toString("hex")}.tmp` : `${filePath}.tmp`;
+}
+var IS_WINDOWS = process.platform === "win32";
+var RENAME_RETRY_DELAYS_MS = [
+	30,
+	100,
+	300
+];
+function hasErrnoCode(err) {
+	return typeof err === "object" && err !== null && "code" in err && typeof err.code === "string";
+}
+function isTransientRenameError(err, isWindows = IS_WINDOWS) {
+	if (!isWindows || !hasErrnoCode(err)) return false;
+	return err.code === "EPERM" || err.code === "EBUSY" || err.code === "EACCES";
+}
+var defaultRenameRetryDeps = {
+	rename: (fromPath, toPath) => node_fs.promises.rename(fromPath, toPath),
+	sleep: (millis) => new Promise((resolve) => setTimeout(resolve, millis)),
+	isWindows: IS_WINDOWS
+};
+async function renameWithWindowsRetry(fromPath, toPath, deps = defaultRenameRetryDeps) {
+	for (const delayMs of RENAME_RETRY_DELAYS_MS) try {
+		await deps.rename(fromPath, toPath);
+		return;
+	} catch (err) {
+		if (!isTransientRenameError(err, deps.isWindows)) throw err;
+		await deps.sleep(delayMs);
+	}
+	await deps.rename(fromPath, toPath);
+}
+var SYNC_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(millis) {
+	Atomics.wait(SYNC_SLEEP_BUF, 0, 0, millis);
+}
+var defaultRenameRetryDepsSync = {
+	rename: (fromPath, toPath) => (0, node_fs.renameSync)(fromPath, toPath),
+	sleep: sleepSync,
+	isWindows: IS_WINDOWS
+};
+function renameSyncWithWindowsRetry(fromPath, toPath, deps = defaultRenameRetryDepsSync) {
+	for (const delayMs of RENAME_RETRY_DELAYS_MS) try {
+		deps.rename(fromPath, toPath);
+		return;
+	} catch (err) {
+		if (!isTransientRenameError(err, deps.isWindows)) throw err;
+		deps.sleep(delayMs);
+	}
+	deps.rename(fromPath, toPath);
+}
+function writeOptionsFor(content, mode) {
+	return typeof content === "string" ? {
+		encoding: "utf-8",
+		mode
+	} : { mode };
+}
+async function writeFileAtomic(filePath, content, opts = {}) {
+	const tmp = tmpPathFor(filePath, opts.uniqueTmp);
+	await node_fs.promises.mkdir(node_path.default.dirname(filePath), { recursive: true });
+	try {
+		await node_fs.promises.writeFile(tmp, content, writeOptionsFor(content, opts.mode));
+		await renameWithWindowsRetry(tmp, filePath);
+	} catch (err) {
+		await node_fs.promises.unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+function writeFileAtomicSync(filePath, content, opts = {}) {
+	const tmp = tmpPathFor(filePath, opts.uniqueTmp);
+	(0, node_fs.mkdirSync)(node_path.default.dirname(filePath), { recursive: true });
+	try {
+		(0, node_fs.writeFileSync)(tmp, content, writeOptionsFor(content, opts.mode));
+		renameSyncWithWindowsRetry(tmp, filePath);
+	} catch (err) {
+		try {
+			(0, node_fs.unlinkSync)(tmp);
+		} catch {}
+		throw err;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "writeFileAtomic", {
+	enumerable: true,
+	get: function() {
+		return writeFileAtomic;
+	}
+});
+Object.defineProperty(exports, "writeFileAtomicSync", {
+	enumerable: true,
+	get: function() {
+		return writeFileAtomicSync;
+	}
+});
+
+//# sourceMappingURL=atomic-C_7YpMiM.cjs.map

package/dist/atomic-C_7YpMiM.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-C_7YpMiM.cjs","names":[],"sources":["../src/files/atomic.ts"],"sourcesContent":["// rename(2) is atomic on POSIX; Node's Windows fallback (copy+unlink) is still safer than truncating in place.\n// Readers always see either the old file or the new — never a half-written one.\n//\n// Single source of truth for atomic file writes across the whole monorepo\n// (host, core, plugins). Previously copy-pasted four times, so a Windows retry\n// fix landed in only one (#2399, precedent #2222).\n\nimport { mkdirSync, promises, renameSync, unlinkSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { randomBytes } from \"node:crypto\";\n\nexport interface WriteAtomicOptions {\n  mode?: number;\n  /** Give the staging file a random suffix so concurrent writers to the same\n   *  destination can't collide at the OS layer.\n   *\n   *  Defaults to `true`, and opting out is almost always wrong. A shared\n   *  `${filePath}.tmp` means two writers of one file race: the second write\n   *  overwrites the first's staging file, or one rename/unlink pulls it out\n   *  from under the other, surfacing as `ENOENT … rename '<file>.tmp'`. That is\n   *  not theoretical — it fired in production on session meta, where ten\n   *  distinct callers (`setClaudeSessionId`, `backfillOrigin`,\n   *  `incrementUserQueryCount`, …) all write the same `<sessionId>.json`\n   *  (#2222).\n   *\n   *  Pass `false` only when you specifically need the staging path to be\n   *  predictable (e.g. a single-writer token file, or a test that pre-creates\n   *  it to force a write failure). */\n  uniqueTmp?: boolean;\n}\n\n// Unique staging names are the safe default: the cost is a random suffix, the\n// cost of the alternative is a lost update under concurrency (#2222).\nconst DEFAULT_UNIQUE_TMP = true;\n\nfunction tmpPathFor(filePath: string, uniqueTmp: boolean | undefined): string {\n  return (uniqueTmp ?? DEFAULT_UNIQUE_TMP) ? `${filePath}.${randomBytes(6).toString(\"hex\")}.tmp` : `${filePath}.tmp`;\n}\n\n// On Windows, AV / Search Indexer / Defender briefly hold handles and rename trips EPERM/EBUSY/EACCES. Retry loop is\n// gated to Windows because POSIX EPERM means a real perm problem (read-only fs, sticky, cross-device) — retrying\n// just adds latency before the inevitable throw.\nconst IS_WINDOWS = process.platform === \"win32\";\nconst RENAME_RETRY_DELAYS_MS = [30, 100, 300] as const;\n\nfunction hasErrnoCode(err: unknown): err is { code: string } {\n  return typeof err === \"object\" && err !== null && \"code\" in err && typeof err.code === \"string\";\n}\n\n// `isWindows` is a parameter (defaulting to the real platform) so the safety-critical decision is testable on any OS.\nexport function isTransientRenameError(err: unknown, isWindows: boolean = IS_WINDOWS): boolean {\n  if (!isWindows || !hasErrnoCode(err)) return false;\n  return err.code === \"EPERM\" || err.code === \"EBUSY\" || err.code === \"EACCES\";\n}\n\n// Injectable so a test can drive the retry path (fail-then-succeed rename, no-op sleep, isWindows=true) on any OS.\nexport interface RenameRetryDeps {\n  rename: (fromPath: string, toPath: string) => Promise<void>;\n  sleep: (millis: number) => Promise<void>;\n  isWindows: boolean;\n}\n\nconst defaultRenameRetryDeps: RenameRetryDeps = {\n  rename: (fromPath, toPath) => promises.rename(fromPath, toPath),\n  sleep: (millis) => new Promise((resolve) => setTimeout(resolve, millis)),\n  isWindows: IS_WINDOWS,\n};\n\nexport async function renameWithWindowsRetry(fromPath: string, toPath: string, deps: RenameRetryDeps = defaultRenameRetryDeps): Promise<void> {\n  for (const delayMs of RENAME_RETRY_DELAYS_MS) {\n    try {\n      await deps.rename(fromPath, toPath);\n      return;\n    } catch (err) {\n      if (!isTransientRenameError(err, deps.isWindows)) throw err;\n      await deps.sleep(delayMs);\n    }\n  }\n  // Final attempt — let any error propagate.\n  await deps.rename(fromPath, toPath);\n}\n\n// Atomics.wait parks the thread instead of busy-spinning. Only on the Windows-rename retry path, total ≤ ~430ms.\nconst SYNC_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));\nfunction sleepSync(millis: number): void {\n  Atomics.wait(SYNC_SLEEP_BUF, 0, 0, millis);\n}\n\n// Deliberate async/sync twin of RenameRetryDeps: `sleep` blocks the thread instead of returning a Promise.\nexport interface RenameRetryDepsSync {\n  rename: (fromPath: string, toPath: string) => void;\n  sleep: (millis: number) => void;\n  isWindows: boolean;\n}\n\nconst defaultRenameRetryDepsSync: RenameRetryDepsSync = {\n  rename: (fromPath, toPath) => renameSync(fromPath, toPath),\n  sleep: sleepSync,\n  isWindows: IS_WINDOWS,\n};\n\nexport function renameSyncWithWindowsRetry(fromPath: string, toPath: string, deps: RenameRetryDepsSync = defaultRenameRetryDepsSync): void {\n  for (const delayMs of RENAME_RETRY_DELAYS_MS) {\n    try {\n      deps.rename(fromPath, toPath);\n      return;\n    } catch (err) {\n      if (!isTransientRenameError(err, deps.isWindows)) throw err;\n      deps.sleep(delayMs);\n    }\n  }\n  deps.rename(fromPath, toPath);\n}\n\n// Forcing utf-8 on a Uint8Array would re-encode the bytes — wrong for PNGs and other binary blobs.\nfunction writeOptionsFor(content: string | Uint8Array, mode: number | undefined): { encoding?: \"utf-8\"; mode?: number } {\n  return typeof content === \"string\" ? { encoding: \"utf-8\", mode } : { mode };\n}\n\nexport async function writeFileAtomic(filePath: string, content: string | Uint8Array, opts: WriteAtomicOptions = {}): Promise<void> {\n  const tmp = tmpPathFor(filePath, opts.uniqueTmp);\n  await promises.mkdir(path.dirname(filePath), { recursive: true });\n  try {\n    await promises.writeFile(tmp, content, writeOptionsFor(content, opts.mode));\n    await renameWithWindowsRetry(tmp, filePath);\n  } catch (err) {\n    await promises.unlink(tmp).catch(() => {});\n    throw err;\n  }\n}\n\nexport function writeFileAtomicSync(filePath: string, content: string | Uint8Array, opts: WriteAtomicOptions = {}): void {\n  const tmp = tmpPathFor(filePath, opts.uniqueTmp);\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  try {\n    writeFileSync(tmp, content, writeOptionsFor(content, opts.mode));\n    renameSyncWithWindowsRetry(tmp, filePath);\n  } catch (err) {\n    try {\n      unlinkSync(tmp);\n    } catch {\n      // best-effort cleanup\n    }\n    throw err;\n  }\n}\n"],"mappings":";;;;;;AAiCA,IAAM,qBAAqB;AAE3B,SAAS,WAAW,UAAkB,WAAwC;CAC5E,OAAQ,aAAa,qBAAsB,GAAG,SAAS,IAAA,GAAA,YAAA,YAAA,CAAe,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,QAAQ,GAAG,SAAS;AAC/G;AAKA,IAAM,aAAa,QAAQ,aAAa;AACxC,IAAM,yBAAyB;CAAC;CAAI;CAAK;AAAG;AAE5C,SAAS,aAAa,KAAuC;CAC3D,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU,OAAO,OAAO,IAAI,SAAS;AACzF;AAGA,SAAgB,uBAAuB,KAAc,YAAqB,YAAqB;CAC7F,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,GAAG,OAAO;CAC7C,OAAO,IAAI,SAAS,WAAW,IAAI,SAAS,WAAW,IAAI,SAAS;AACtE;AASA,IAAM,yBAA0C;CAC9C,SAAS,UAAU,WAAW,QAAA,SAAS,OAAO,UAAU,MAAM;CAC9D,QAAQ,WAAW,IAAI,SAAS,YAAY,WAAW,SAAS,MAAM,CAAC;CACvE,WAAW;AACb;AAEA,eAAsB,uBAAuB,UAAkB,QAAgB,OAAwB,wBAAuC;CAC5I,KAAK,MAAM,WAAW,wBACpB,IAAI;EACF,MAAM,KAAK,OAAO,UAAU,MAAM;EAClC;CACF,SAAS,KAAK;EACZ,IAAI,CAAC,uBAAuB,KAAK,KAAK,SAAS,GAAG,MAAM;EACxD,MAAM,KAAK,MAAM,OAAO;CAC1B;CAGF,MAAM,KAAK,OAAO,UAAU,MAAM;AACpC;AAGA,IAAM,iBAAiB,IAAI,WAAW,IAAI,kBAAkB,CAAC,CAAC;AAC9D,SAAS,UAAU,QAAsB;CACvC,QAAQ,KAAK,gBAAgB,GAAG,GAAG,MAAM;AAC3C;AASA,IAAM,6BAAkD;CACtD,SAAS,UAAU,YAAA,GAAA,QAAA,WAAA,CAAsB,UAAU,MAAM;CACzD,OAAO;CACP,WAAW;AACb;AAEA,SAAgB,2BAA2B,UAAkB,QAAgB,OAA4B,4BAAkC;CACzI,KAAK,MAAM,WAAW,wBACpB,IAAI;EACF,KAAK,OAAO,UAAU,MAAM;EAC5B;CACF,SAAS,KAAK;EACZ,IAAI,CAAC,uBAAuB,KAAK,KAAK,SAAS,GAAG,MAAM;EACxD,KAAK,MAAM,OAAO;CACpB;CAEF,KAAK,OAAO,UAAU,MAAM;AAC9B;AAGA,SAAS,gBAAgB,SAA8B,MAAiE;CACtH,OAAO,OAAO,YAAY,WAAW;EAAE,UAAU;EAAS;CAAK,IAAI,EAAE,KAAK;AAC5E;AAEA,eAAsB,gBAAgB,UAAkB,SAA8B,OAA2B,CAAC,GAAkB;CAClI,MAAM,MAAM,WAAW,UAAU,KAAK,SAAS;CAC/C,MAAM,QAAA,SAAS,MAAM,UAAA,QAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;CAChE,IAAI;EACF,MAAM,QAAA,SAAS,UAAU,KAAK,SAAS,gBAAgB,SAAS,KAAK,IAAI,CAAC;EAC1E,MAAM,uBAAuB,KAAK,QAAQ;CAC5C,SAAS,KAAK;EACZ,MAAM,QAAA,SAAS,OAAO,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC;EACzC,MAAM;CACR;AACF;AAEA,SAAgB,oBAAoB,UAAkB,SAA8B,OAA2B,CAAC,GAAS;CACvH,MAAM,MAAM,WAAW,UAAU,KAAK,SAAS;CAC/C,CAAA,GAAA,QAAA,UAAA,CAAU,UAAA,QAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;CACrD,IAAI;EACF,CAAA,GAAA,QAAA,cAAA,CAAc,KAAK,SAAS,gBAAgB,SAAS,KAAK,IAAI,CAAC;EAC/D,2BAA2B,KAAK,QAAQ;CAC1C,SAAS,KAAK;EACZ,IAAI;GACF,CAAA,GAAA,QAAA,WAAA,CAAW,GAAG;EAChB,QAAQ,CAER;EACA,MAAM;CACR;AACF"}

package/dist/atomic-DPpdrJzO.js

@@ -0,0 +1,89 @@
+import { mkdirSync, promises, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+//#region src/files/atomic.ts
+var DEFAULT_UNIQUE_TMP = true;
+function tmpPathFor(filePath, uniqueTmp) {
+	return uniqueTmp ?? DEFAULT_UNIQUE_TMP ? `${filePath}.${randomBytes(6).toString("hex")}.tmp` : `${filePath}.tmp`;
+}
+var IS_WINDOWS = process.platform === "win32";
+var RENAME_RETRY_DELAYS_MS = [
+	30,
+	100,
+	300
+];
+function hasErrnoCode(err) {
+	return typeof err === "object" && err !== null && "code" in err && typeof err.code === "string";
+}
+function isTransientRenameError(err, isWindows = IS_WINDOWS) {
+	if (!isWindows || !hasErrnoCode(err)) return false;
+	return err.code === "EPERM" || err.code === "EBUSY" || err.code === "EACCES";
+}
+var defaultRenameRetryDeps = {
+	rename: (fromPath, toPath) => promises.rename(fromPath, toPath),
+	sleep: (millis) => new Promise((resolve) => setTimeout(resolve, millis)),
+	isWindows: IS_WINDOWS
+};
+async function renameWithWindowsRetry(fromPath, toPath, deps = defaultRenameRetryDeps) {
+	for (const delayMs of RENAME_RETRY_DELAYS_MS) try {
+		await deps.rename(fromPath, toPath);
+		return;
+	} catch (err) {
+		if (!isTransientRenameError(err, deps.isWindows)) throw err;
+		await deps.sleep(delayMs);
+	}
+	await deps.rename(fromPath, toPath);
+}
+var SYNC_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(millis) {
+	Atomics.wait(SYNC_SLEEP_BUF, 0, 0, millis);
+}
+var defaultRenameRetryDepsSync = {
+	rename: (fromPath, toPath) => renameSync(fromPath, toPath),
+	sleep: sleepSync,
+	isWindows: IS_WINDOWS
+};
+function renameSyncWithWindowsRetry(fromPath, toPath, deps = defaultRenameRetryDepsSync) {
+	for (const delayMs of RENAME_RETRY_DELAYS_MS) try {
+		deps.rename(fromPath, toPath);
+		return;
+	} catch (err) {
+		if (!isTransientRenameError(err, deps.isWindows)) throw err;
+		deps.sleep(delayMs);
+	}
+	deps.rename(fromPath, toPath);
+}
+function writeOptionsFor(content, mode) {
+	return typeof content === "string" ? {
+		encoding: "utf-8",
+		mode
+	} : { mode };
+}
+async function writeFileAtomic(filePath, content, opts = {}) {
+	const tmp = tmpPathFor(filePath, opts.uniqueTmp);
+	await promises.mkdir(path.dirname(filePath), { recursive: true });
+	try {
+		await promises.writeFile(tmp, content, writeOptionsFor(content, opts.mode));
+		await renameWithWindowsRetry(tmp, filePath);
+	} catch (err) {
+		await promises.unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+function writeFileAtomicSync(filePath, content, opts = {}) {
+	const tmp = tmpPathFor(filePath, opts.uniqueTmp);
+	mkdirSync(path.dirname(filePath), { recursive: true });
+	try {
+		writeFileSync(tmp, content, writeOptionsFor(content, opts.mode));
+		renameSyncWithWindowsRetry(tmp, filePath);
+	} catch (err) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw err;
+	}
+}
+//#endregion
+export { writeFileAtomicSync as n, writeFileAtomic as t };
+
+//# sourceMappingURL=atomic-DPpdrJzO.js.map

package/dist/atomic-DPpdrJzO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-DPpdrJzO.js","names":[],"sources":["../src/files/atomic.ts"],"sourcesContent":["// rename(2) is atomic on POSIX; Node's Windows fallback (copy+unlink) is still safer than truncating in place.\n// Readers always see either the old file or the new — never a half-written one.\n//\n// Single source of truth for atomic file writes across the whole monorepo\n// (host, core, plugins). Previously copy-pasted four times, so a Windows retry\n// fix landed in only one (#2399, precedent #2222).\n\nimport { mkdirSync, promises, renameSync, unlinkSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { randomBytes } from \"node:crypto\";\n\nexport interface WriteAtomicOptions {\n  mode?: number;\n  /** Give the staging file a random suffix so concurrent writers to the same\n   *  destination can't collide at the OS layer.\n   *\n   *  Defaults to `true`, and opting out is almost always wrong. A shared\n   *  `${filePath}.tmp` means two writers of one file race: the second write\n   *  overwrites the first's staging file, or one rename/unlink pulls it out\n   *  from under the other, surfacing as `ENOENT … rename '<file>.tmp'`. That is\n   *  not theoretical — it fired in production on session meta, where ten\n   *  distinct callers (`setClaudeSessionId`, `backfillOrigin`,\n   *  `incrementUserQueryCount`, …) all write the same `<sessionId>.json`\n   *  (#2222).\n   *\n   *  Pass `false` only when you specifically need the staging path to be\n   *  predictable (e.g. a single-writer token file, or a test that pre-creates\n   *  it to force a write failure). */\n  uniqueTmp?: boolean;\n}\n\n// Unique staging names are the safe default: the cost is a random suffix, the\n// cost of the alternative is a lost update under concurrency (#2222).\nconst DEFAULT_UNIQUE_TMP = true;\n\nfunction tmpPathFor(filePath: string, uniqueTmp: boolean | undefined): string {\n  return (uniqueTmp ?? DEFAULT_UNIQUE_TMP) ? `${filePath}.${randomBytes(6).toString(\"hex\")}.tmp` : `${filePath}.tmp`;\n}\n\n// On Windows, AV / Search Indexer / Defender briefly hold handles and rename trips EPERM/EBUSY/EACCES. Retry loop is\n// gated to Windows because POSIX EPERM means a real perm problem (read-only fs, sticky, cross-device) — retrying\n// just adds latency before the inevitable throw.\nconst IS_WINDOWS = process.platform === \"win32\";\nconst RENAME_RETRY_DELAYS_MS = [30, 100, 300] as const;\n\nfunction hasErrnoCode(err: unknown): err is { code: string } {\n  return typeof err === \"object\" && err !== null && \"code\" in err && typeof err.code === \"string\";\n}\n\n// `isWindows` is a parameter (defaulting to the real platform) so the safety-critical decision is testable on any OS.\nexport function isTransientRenameError(err: unknown, isWindows: boolean = IS_WINDOWS): boolean {\n  if (!isWindows || !hasErrnoCode(err)) return false;\n  return err.code === \"EPERM\" || err.code === \"EBUSY\" || err.code === \"EACCES\";\n}\n\n// Injectable so a test can drive the retry path (fail-then-succeed rename, no-op sleep, isWindows=true) on any OS.\nexport interface RenameRetryDeps {\n  rename: (fromPath: string, toPath: string) => Promise<void>;\n  sleep: (millis: number) => Promise<void>;\n  isWindows: boolean;\n}\n\nconst defaultRenameRetryDeps: RenameRetryDeps = {\n  rename: (fromPath, toPath) => promises.rename(fromPath, toPath),\n  sleep: (millis) => new Promise((resolve) => setTimeout(resolve, millis)),\n  isWindows: IS_WINDOWS,\n};\n\nexport async function renameWithWindowsRetry(fromPath: string, toPath: string, deps: RenameRetryDeps = defaultRenameRetryDeps): Promise<void> {\n  for (const delayMs of RENAME_RETRY_DELAYS_MS) {\n    try {\n      await deps.rename(fromPath, toPath);\n      return;\n    } catch (err) {\n      if (!isTransientRenameError(err, deps.isWindows)) throw err;\n      await deps.sleep(delayMs);\n    }\n  }\n  // Final attempt — let any error propagate.\n  await deps.rename(fromPath, toPath);\n}\n\n// Atomics.wait parks the thread instead of busy-spinning. Only on the Windows-rename retry path, total ≤ ~430ms.\nconst SYNC_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));\nfunction sleepSync(millis: number): void {\n  Atomics.wait(SYNC_SLEEP_BUF, 0, 0, millis);\n}\n\n// Deliberate async/sync twin of RenameRetryDeps: `sleep` blocks the thread instead of returning a Promise.\nexport interface RenameRetryDepsSync {\n  rename: (fromPath: string, toPath: string) => void;\n  sleep: (millis: number) => void;\n  isWindows: boolean;\n}\n\nconst defaultRenameRetryDepsSync: RenameRetryDepsSync = {\n  rename: (fromPath, toPath) => renameSync(fromPath, toPath),\n  sleep: sleepSync,\n  isWindows: IS_WINDOWS,\n};\n\nexport function renameSyncWithWindowsRetry(fromPath: string, toPath: string, deps: RenameRetryDepsSync = defaultRenameRetryDepsSync): void {\n  for (const delayMs of RENAME_RETRY_DELAYS_MS) {\n    try {\n      deps.rename(fromPath, toPath);\n      return;\n    } catch (err) {\n      if (!isTransientRenameError(err, deps.isWindows)) throw err;\n      deps.sleep(delayMs);\n    }\n  }\n  deps.rename(fromPath, toPath);\n}\n\n// Forcing utf-8 on a Uint8Array would re-encode the bytes — wrong for PNGs and other binary blobs.\nfunction writeOptionsFor(content: string | Uint8Array, mode: number | undefined): { encoding?: \"utf-8\"; mode?: number } {\n  return typeof content === \"string\" ? { encoding: \"utf-8\", mode } : { mode };\n}\n\nexport async function writeFileAtomic(filePath: string, content: string | Uint8Array, opts: WriteAtomicOptions = {}): Promise<void> {\n  const tmp = tmpPathFor(filePath, opts.uniqueTmp);\n  await promises.mkdir(path.dirname(filePath), { recursive: true });\n  try {\n    await promises.writeFile(tmp, content, writeOptionsFor(content, opts.mode));\n    await renameWithWindowsRetry(tmp, filePath);\n  } catch (err) {\n    await promises.unlink(tmp).catch(() => {});\n    throw err;\n  }\n}\n\nexport function writeFileAtomicSync(filePath: string, content: string | Uint8Array, opts: WriteAtomicOptions = {}): void {\n  const tmp = tmpPathFor(filePath, opts.uniqueTmp);\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  try {\n    writeFileSync(tmp, content, writeOptionsFor(content, opts.mode));\n    renameSyncWithWindowsRetry(tmp, filePath);\n  } catch (err) {\n    try {\n      unlinkSync(tmp);\n    } catch {\n      // best-effort cleanup\n    }\n    throw err;\n  }\n}\n"],"mappings":";;;;AAiCA,IAAM,qBAAqB;AAE3B,SAAS,WAAW,UAAkB,WAAwC;CAC5E,OAAQ,aAAa,qBAAsB,GAAG,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,QAAQ,GAAG,SAAS;AAC/G;AAKA,IAAM,aAAa,QAAQ,aAAa;AACxC,IAAM,yBAAyB;CAAC;CAAI;CAAK;AAAG;AAE5C,SAAS,aAAa,KAAuC;CAC3D,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU,OAAO,OAAO,IAAI,SAAS;AACzF;AAGA,SAAgB,uBAAuB,KAAc,YAAqB,YAAqB;CAC7F,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,GAAG,OAAO;CAC7C,OAAO,IAAI,SAAS,WAAW,IAAI,SAAS,WAAW,IAAI,SAAS;AACtE;AASA,IAAM,yBAA0C;CAC9C,SAAS,UAAU,WAAW,SAAS,OAAO,UAAU,MAAM;CAC9D,QAAQ,WAAW,IAAI,SAAS,YAAY,WAAW,SAAS,MAAM,CAAC;CACvE,WAAW;AACb;AAEA,eAAsB,uBAAuB,UAAkB,QAAgB,OAAwB,wBAAuC;CAC5I,KAAK,MAAM,WAAW,wBACpB,IAAI;EACF,MAAM,KAAK,OAAO,UAAU,MAAM;EAClC;CACF,SAAS,KAAK;EACZ,IAAI,CAAC,uBAAuB,KAAK,KAAK,SAAS,GAAG,MAAM;EACxD,MAAM,KAAK,MAAM,OAAO;CAC1B;CAGF,MAAM,KAAK,OAAO,UAAU,MAAM;AACpC;AAGA,IAAM,iBAAiB,IAAI,WAAW,IAAI,kBAAkB,CAAC,CAAC;AAC9D,SAAS,UAAU,QAAsB;CACvC,QAAQ,KAAK,gBAAgB,GAAG,GAAG,MAAM;AAC3C;AASA,IAAM,6BAAkD;CACtD,SAAS,UAAU,WAAW,WAAW,UAAU,MAAM;CACzD,OAAO;CACP,WAAW;AACb;AAEA,SAAgB,2BAA2B,UAAkB,QAAgB,OAA4B,4BAAkC;CACzI,KAAK,MAAM,WAAW,wBACpB,IAAI;EACF,KAAK,OAAO,UAAU,MAAM;EAC5B;CACF,SAAS,KAAK;EACZ,IAAI,CAAC,uBAAuB,KAAK,KAAK,SAAS,GAAG,MAAM;EACxD,KAAK,MAAM,OAAO;CACpB;CAEF,KAAK,OAAO,UAAU,MAAM;AAC9B;AAGA,SAAS,gBAAgB,SAA8B,MAAiE;CACtH,OAAO,OAAO,YAAY,WAAW;EAAE,UAAU;EAAS;CAAK,IAAI,EAAE,KAAK;AAC5E;AAEA,eAAsB,gBAAgB,UAAkB,SAA8B,OAA2B,CAAC,GAAkB;CAClI,MAAM,MAAM,WAAW,UAAU,KAAK,SAAS;CAC/C,MAAM,SAAS,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;CAChE,IAAI;EACF,MAAM,SAAS,UAAU,KAAK,SAAS,gBAAgB,SAAS,KAAK,IAAI,CAAC;EAC1E,MAAM,uBAAuB,KAAK,QAAQ;CAC5C,SAAS,KAAK;EACZ,MAAM,SAAS,OAAO,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC;EACzC,MAAM;CACR;AACF;AAEA,SAAgB,oBAAoB,UAAkB,SAA8B,OAA2B,CAAC,GAAS;CACvH,MAAM,MAAM,WAAW,UAAU,KAAK,SAAS;CAC/C,UAAU,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;CACrD,IAAI;EACF,cAAc,KAAK,SAAS,gBAAgB,SAAS,KAAK,IAAI,CAAC;EAC/D,2BAA2B,KAAK,QAAQ;CAC1C,SAAS,KAAK;EACZ,IAAI;GACF,WAAW,GAAG;EAChB,QAAQ,CAER;EACA,MAAM;CACR;AACF"}

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

@@ -0,0 +1,4 @@
+/** `/<slug> <message>`, or `/<slug> id=<itemId> <message>` when a specific
+ *  record is addressed. The `id=` selector goes BEFORE the free-text message so
+ *  the skill's argument parser reads it as a flag rather than as prose. */
+export declare function skillCommandSeed(slug: string, message: string, itemId?: string): string;

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

@@ -1,4 +1,5 @@
 import { Where } from './where';
+import { CollectionFieldSpec, CollectionItem } from './schema';
 /** 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. */
@@ -16,3 +17,55 @@ export interface CompletionSchemaView {
 /** 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;
+/** The schema slice `completionCoveredByFieldChip` reads: field kinds (it
+ *  inspects `boolean` / `toggle` variants' `field` / `onValue`) plus the
+ *  completion pair. Minimal structural shape so both the client and server
+ *  `CollectionSchema` types satisfy it as-is. */
+export interface CompletionChipSchemaView {
+    fields: Record<string, {
+        type: string;
+        field?: string;
+        onValue?: string;
+    }>;
+    completionField?: string;
+    completionDoneValues?: readonly string[];
+}
+/** True when an existing FIELD chip already expresses the legacy completion
+ *  predicate exactly, so a synthesized "done" chip would be a duplicate: a
+ *  boolean `completionField` (done ⇔ `"true"` ⇔ the boolean's own chip), or a
+ *  `toggle` projecting the `completionField` whose `onValue` is the single
+ *  done value (the todos-schema shape: toggle "Done" on `status` +
+ *  `completionDoneValues: ["done"]`). A superset pair (extra done values)
+ *  still synthesizes — no field chip covers it. */
+export declare function completionCoveredByFieldChip(schema: CompletionChipSchemaView): boolean;
+/** Whether a `toggle` field reads as checked: its projected enum field currently
+ *  equals `onValue`. The toggle stores nothing of its own, so this reads the raw
+ *  projected value; a non-toggle field is never checked. */
+export declare function toggleChecked(item: CollectionItem, field: CollectionFieldSpec): boolean;
+/** A `flag` FIELD's boolean for one row, read off the already-enriched record
+ *  (so a flag computed from derived/rollup inputs is correct). Strict `=== true`
+ *  on purpose: a truthy non-boolean ("yes", 1) is NOT a set flag, so a stray
+ *  value can never render as an active flag. */
+export declare function flagFieldValue(record: Record<string, unknown>, key: string): boolean;
+/** One entry in the table's flag-filter menu: a real `flag` / `boolean` /
+ *  `toggle` field, or the synthesized legacy-completion chip (`synthetic`,
+ *  predicate = `itemIsDone`). */
+export interface FlagChip {
+    key: string;
+    label: string;
+    synthetic?: boolean;
+}
+/** The schema slice `chipMatches` reads: full field specs (it inspects the
+ *  `toggle` variant's `field` / `onValue`) plus the completion pair that
+ *  `itemIsDone` needs for the synthesized chip. */
+export interface ChipMatchSchema {
+    fields: Record<string, CollectionFieldSpec>;
+    completionField?: string;
+    completionDoneValues?: readonly string[];
+}
+/** Whether one row satisfies a chip's predicate: `itemIsDone` for the
+ *  synthesized completion chip, the projected value for a `toggle`, the stored
+ *  boolean for a `boolean`, else the computed flag value. The flag branch reads
+ *  the ENRICHED record via the injected `deriveRecord` (kept a parameter so this
+ *  stays pure and framework-free). */
+export declare function chipMatches(chip: FlagChip, schema: ChipMatchSchema, item: CollectionItem, deriveRecord: (item: CollectionItem) => Record<string, unknown>): boolean;

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

@@ -1,3 +1,4 @@
+import { CollectionItem } from './schema';
 export declare const SAFE_SLUG_PATTERN: RegExp;
 export declare const SAFE_RECORD_ID_PATTERN: RegExp;
 /** True when `value` is a well-formed collection slug (alphanumeric /
@@ -10,3 +11,12 @@ export declare function isSafeSlug(value: string): boolean;
  *  dots), with any `..` substring rejected explicitly. Validation-only
  *  counterpart of `../server/paths#safeRecordId`. */
 export declare function isSafeRecordId(value: string): boolean;
+/** Pick an id not already in `existing`, re-rolling `generate()` up to
+ *  `maxAttempts` times before giving up and returning the last candidate.
+ *  Collisions on a wide id space are astronomically unlikely, so a caller's
+ *  own overwrite guard is the final backstop rather than an unbounded loop. */
+export declare function generateUniqueId(existing: ReadonlySet<string>, generate: () => string, maxAttempts?: number): string;
+/** An id not already used by any loaded record: collects the in-memory primary
+ *  keys and re-rolls `generate()` against them (see {@link generateUniqueId}).
+ *  The pure core of the view's create-form id prefill. */
+export declare function nextUniqueItemId(items: readonly CollectionItem[], primaryKey: string, generate: () => string, maxAttempts?: number): string;

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

@@ -0,0 +1,14 @@
+import { CollectionSchema } from './schema';
+/** Slugs of every collection referenced by a `ref` field — top-level and
+ *  one level into `table` sub-fields (nested tables are schema-rejected,
+ *  so a single recursion suffices). */
+export declare function uniqueRefTargets(schema: CollectionSchema): string[];
+/** Slugs of every collection referenced by an `embed` field. Top-level
+ *  only — the schema rejects `embed` inside a table's `of`, so no
+ *  recursion. */
+export declare function uniqueEmbedTargets(schema: CollectionSchema): string[];
+/** Slugs of every SOURCE collection a `backlinks` or `rollup` field
+ *  reverses over — loaded once (the two field kinds share one load).
+ *  Top-level only, like `embed` (the schema rejects both inside a table's
+ *  `of`). */
+export declare function uniqueBacklinkSources(schema: CollectionSchema): string[];

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

@@ -0,0 +1,9 @@
+/** Read `obj[key]` only when it is an OWN property. A bare `obj[key]` reaches
+ *  inherited Object.prototype members, so a dangling ref/embed id like
+ *  `"constructor"` or `"__proto__"` resolves to a prototype value (the
+ *  `Object` function) instead of being absent — breaking the "missing target
+ *  ⇒ null (em-dash)" fail-soft contract and putting a non-serializable
+ *  function into the API response, where `JSON.stringify` drops the key
+ *  entirely (#2322). A prototype key resolves to `undefined`; a record whose
+ *  id is legitimately `"constructor"` (an own key) still resolves. */
+export declare function ownProp<T>(obj: Record<string, T>, key: string): T | undefined;

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

@@ -0,0 +1,21 @@
+import { CollectionItem } from './schema';
+/** The schema slice `snapshotEmptyEnums` reads — minimal structural shape so
+ *  both the client and server collection-schema types satisfy it as-is. */
+export interface EnumSnapshotSchema {
+    fields: Record<string, {
+        type: string;
+    }>;
+    primaryKey: string;
+}
+/** Stable key for one cell (`<rowId>:<fieldKey>`) in the per-cell state maps. */
+export declare function cellKey(rowId: string, fieldKey: string): string;
+/** A row's stable identity: the primary-key value as text (`""` when the schema
+ *  has no primary key, or the value is absent). Every per-row / per-cell state
+ *  map keys off this, and it is the SAME derivation `snapshotEmptyEnums` uses
+ *  for its record ids (`fieldText`), so `cellKey(rowIdOf(...), field)` and the
+ *  empty-enum snapshot always agree. A real primary key is a scalar, so this
+ *  matches its plain string form. */
+export declare function rowIdOf(primaryKey: string | undefined, item: CollectionItem): string;
+/** The set of enum cells that were empty in the freshly-fetched records — the
+ *  only cells whose inline dropdown offers an empty option. */
+export declare function snapshotEmptyEnums(schema: EnumSnapshotSchema, records: CollectionItem[]): Set<string>;