@mulmoclaude/core 0.8.0 → 0.8.2

package/assets/helps/billing-clients-worklog.md

@@ -26,8 +26,10 @@ user opens it at `/collections/<slug>`). **Do not use the `mc-` prefix.**
 > mimic other collections in the workspace. The whole point is a reproducible
 > billing suite. (If the user wants a *custom* collection instead, that's a
 > different task — use `config/helps/collection-skills.md`.) Existing records
-> under `data/clients/items` / `data/worklog/items` already match these schemas
-> and will render as-is once you author the skill — no data edits needed.
+> under `data/clients/items` / `data/worklog/items` will render as-is **only
+> when `worklog.clientId` values are already slugs AND a matching client
+> record exists for each of them**. If either invariant is violated, the
+> `ref` link breaks — the reconcile step below (§3) fixes both.
 
 ## Slug contract (do not change these)
 
@@ -206,10 +208,76 @@ If the user gives a clear "log N hours for X today", just write it. Use
 
 ---
 
+## 3. Reconcile pre-existing worklog data (MANDATORY before "Done")
+
+Both skills are now authored. Before telling the user setup is complete,
+audit any records that were already on disk under `data/worklog/items/` —
+they may have been written before the `clients` collection existed, so
+`clientId` values can be either display names (`"Singularity Society"`) or
+missing-slug references. Both break the `ref` link at render time.
+
+Run this reconcile every time — even when the setup looks fine — because
+"looks fine" from the LLM side (schemas written, files present) is
+distinct from "the ref actually resolves" (clientId is a valid slug AND
+`data/clients/items/<slug>.json` exists).
+
+**Steps** (idempotent; safe to re-run):
+
+1. **Inventory the existing worklog.** List `data/worklog/items/`. Read
+   every record and collect the distinct `clientId` values seen.
+   *Skip this step only when the directory does not exist at all.*
+2. **For each distinct `clientId` value**, classify it:
+   - **valid slug + matching client file exists** → no action.
+   - **valid slug but no matching `data/clients/items/<slug>.json`** →
+     create a stub client record: `id: <slug>`, `name` derived by
+     title-casing the slug (`acme-corp` → "Acme Corp"), other fields blank
+     so the user can fill them in later.
+   - **not a valid slug** (contains uppercase, spaces, `&`, `.`, etc.) →
+     (a) generate the slug (lowercase, spaces → `-`, drop punctuation,
+     collapse repeat hyphens, strip leading/trailing hyphens); (b)
+     **validate the generated slug against the `clients.id` contract**
+     (see § 1 record shape: `[a-z0-9-]`, 1–48 chars): if it is empty
+     (punctuation-only or all-whitespace input like `"!!!"`), or longer
+     than 48 chars, **stop and ask the user** for a valid slug rather
+     than writing an invalid filename. If it is >48 chars but has
+     meaningful prefix content, propose truncation at 48 (dropping any
+     trailing hyphen) and confirm with the user before proceeding; (c)
+     **check for slug collisions BEFORE writing anything**: if
+     `data/clients/items/<slug>.json` already exists AND its `name`
+     field does not match the display value being reconciled, stop and
+     disambiguate — either append a numeric suffix (`acme-corp-2`)
+     after confirming the new client is genuinely distinct, or ask the
+     user which client the worklog entries belong to. Do **not**
+     silently overwrite an existing client. Also stop when two
+     different display values in the current inventory slugify to the
+     same slug (e.g. `"ACME Corp"` and `"Acme Corp."`); ask the user
+     whether they're the same client (merge to one slug) or distinct
+     (assign each a suffixed slug); (d) create
+     `data/clients/items/<slug>.json` with `id: <slug>`, `name:
+     <original display value>`, other fields blank; (e) rewrite the raw
+     display value inside every affected `data/worklog/items/*.json`
+     to the new slug in the `clientId` field (preserve every other
+     field untouched).
+3. **Report** what changed: how many client records were created and how
+   many worklog `clientId` values were rewritten. Do not summarise the
+   raw records — point at `/collections/clients` and `/collections/worklog`.
+
+If the worklog directory did not exist yet (fresh setup, no pre-existing
+data), this step is a no-op and you can proceed straight to "Done".
+
+**Don't skip this step because the LLM output says "existing records will
+render as-is."** That claim only holds when both invariants (slug format
++ matching client file) are already true; the reconcile confirms them.
+
+---
+
 ## Done
 
 Tell the user the two collections are ready at `/collections/clients` and
 `/collections/worklog`. The bridge mirrors the files and re-scans, so they appear
-without a restart. If invoicing is the goal, point them at the next step: run
-*"Set up invoicing for my business"* (the `config/helps/billing-invoice.md`
-recipe, which references these `clients` and pulls hours from this `worklog`).
+without a restart. If the reconcile in §3 created client stubs or rewrote
+`clientId` values, mention the counts so the user knows to fill in the
+stubs' contact info. If invoicing is the goal, point them at the next
+step: run *"Set up invoicing for my business"* (the
+`config/helps/billing-invoice.md` recipe, which references these
+`clients` and pulls hours from this `worklog`).

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

@@ -0,0 +1,24 @@
+import { CollectionItem, CollectionSchema, DynamicIconSource, DynamicIconSpec } from './schema';
+/** Reduce `records` to the one record that decides the effective icon, per
+ *  `source`'s `where` filter + `from` strategy:
+ *  - pool = `source.where`-filtered records, or every record when unset;
+ *  - an empty pool resolves to `null` (no source record → fallback);
+ *  - `from: "first"` / `"when"` → the first pool record (storage order);
+ *  - `from: "latest"` (default), with `orderBy` given → the pool record
+ *    whose `String(record[orderBy])` sorts highest;
+ *  - `from: "latest"`, with no `orderBy` → the last pool record.
+ *  `recordsById` (the source collection's records keyed by primaryKey)
+ *  resolves any `valueFrom` reference inside `source.where`; omitted for
+ *  callers with no cross-record lookups. */
+export declare function selectDynamicRecord(records: CollectionItem[], source: DynamicIconSource, orderBy: string | undefined, recordsById?: Record<string, CollectionItem>): CollectionItem | null;
+/** Map a resolved source record to the effective icon: `spec.fallback`
+ *  (or the collection's own static `icon`) when there's no record or no
+ *  rule matches; otherwise the `icon` of the first rule whose `where`
+ *  matches the record. `recordsById` resolves any `valueFrom` reference
+ *  inside a rule's `where`, same as `selectDynamicRecord`. */
+export declare function resolveIcon(record: CollectionItem | null, spec: DynamicIconSpec, staticIcon: string, recordsById?: Record<string, CollectionItem>): string;
+/** The first field key (declaration order) whose type is `date` or
+ *  `datetime` — the default `orderBy` for `from: "latest"` when a
+ *  `DynamicIconSource` doesn't name one. `undefined` when the schema has
+ *  no date-like field. */
+export declare function firstDateField(schema: CollectionSchema): string | undefined;

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

@@ -1,3 +1,4 @@
+import { Where } from './where';
 /** 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
@@ -226,6 +227,48 @@ export interface CollectionAction {
      *  shown. */
     when?: CollectionWhen;
 }
+/** One rule in a `dynamicIcon.rules` list: when the resolved source
+ *  record matches `where` (an AND of typed conditions, see {@link Where}),
+ *  the collection's effective launcher icon becomes `icon`. Evaluated top
+ *  to bottom — the first match wins. */
+export interface DynamicIconRule {
+    where: Where;
+    icon: string;
+}
+/** Where a {@link DynamicIconSpec}'s source record comes from: a (possibly
+ *  cross-collection) pool of records, optionally narrowed by `where` and
+ *  reduced to a single record by `from`. */
+export interface DynamicIconSource {
+    /** Slug of the collection to read records from — the collection itself
+     *  (self-reference) or another one (cross-collection). Required. */
+    collection: string;
+    /** How to reduce the (optionally `where`-filtered) pool to one record.
+     *  `"latest"` (default): the record with the greatest `orderBy` value.
+     *  `"first"` / `"when"`: the first record in the pool (storage order). */
+    from?: "latest" | "first" | "when";
+    /** Field compared for `from: "latest"`. Defaults to the source schema's
+     *  first `date`/`datetime` field (declaration order); when the source
+     *  has none, `"latest"` falls back to the last pool record. */
+    orderBy?: string;
+    /** Optional predicate (AND of typed conditions) narrowing the pool
+     *  before `from` reduces it to one record (e.g. restrict a shared
+     *  weather collection to one region). */
+    where?: Where;
+}
+/** Declarative "data state → icon" mapping for a collection's launcher
+ *  shortcut icon (see `CollectionSchema.dynamicIcon`). When absent, the
+ *  launcher icon is the static `schema.icon`, unchanged from before this
+ *  field existed. */
+export interface DynamicIconSpec {
+    /** The record the `rules` are evaluated against. Required. */
+    source: DynamicIconSource;
+    /** First-match-wins list of "resolved record matches `where` → `icon`"
+     *  rules. */
+    rules: DynamicIconRule[];
+    /** Icon used when no source record resolves or no rule matches.
+     *  Defaults to the collection's own static `schema.icon`. */
+    fallback?: string;
+}
 export interface CollectionFieldSpec {
     type: CollectionFieldType;
     label: string;
@@ -426,12 +469,24 @@ export interface CollectionSchema {
      *  `ingest.template`, and the worker edits the records itself. The host's
      *  feeds subsystem narrows this to its richer `IngestSpec`. */
     ingest?: CollectionIngest;
+    /** Optional data-driven override for the launcher shortcut icon: when
+     *  set, the host resolves a record from `dynamicIcon.source` and maps
+     *  it through `dynamicIcon.rules` to compute `CollectionSummary.icon`
+     *  instead of using this static `icon`. Absent ⇒ unchanged static-icon
+     *  behaviour. See `computeCollectionIcon` (server) and
+     *  `selectDynamicRecord`/`resolveIcon` (pure resolver). */
+    dynamicIcon?: DynamicIconSpec;
 }
 export interface CollectionSummary {
     slug: string;
     title: string;
     icon: string;
     source: CollectionSource;
+    /** 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
+     *  update (see `useDynamicShortcutIcons`). */
+    iconSources?: string[];
 }
 export interface CollectionDetail extends CollectionSummary {
     schema: CollectionSchema;

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

@@ -0,0 +1,32 @@
+/** Comparison operators one `WhereCond` may apply to `record[field]`. */
+export type WhereOp = "eq" | "ne" | "in" | "gt" | "gte" | "lt" | "lte" | "contains";
+/** Reads the comparison value from a field instead of a schema literal:
+ *  - `record` set → another record: `recordsById[record][field]` (e.g. a
+ *    `_config` singleton's `defaultCity`, following a per-user setting);
+ *  - `record` omitted → the SAME record being matched (field-to-field, e.g.
+ *    `spent > budget`). */
+export interface ValueRef {
+    record?: string;
+    field: string;
+}
+/** One typed condition: `record[field] <op> value`. The comparison value is
+ *  either a literal `value` (a plain string for every op except `in`, which
+ *  takes the allowed set) or a `valueFrom` reference resolved against the
+ *  `recordsById` map passed to `matchesWhere`. Exactly one of the two is
+ *  expected — enforced by zod at the schema boundary (`server/discovery.ts`),
+ *  not here. */
+export interface WhereCond {
+    field: string;
+    op: WhereOp;
+    value?: string | string[];
+    valueFrom?: ValueRef;
+}
+/** A `where` clause is the AND of its conditions — every one must match. */
+export type Where = WhereCond[];
+/** True when `record` satisfies every condition in `where` (AND). An empty
+ *  `where` matches everything. `recordsById` — the source collection's
+ *  records keyed by primaryKey — resolves any `valueFrom` reference;
+ *  omitted (default `{}`) for callers with no cross-record lookups, in
+ *  which case every `valueFrom` condition is UNRESOLVED and so never
+ *  matches. */
+export declare function matchesWhere(where: Where, record: Record<string, unknown>, recordsById?: Record<string, Record<string, unknown>>): boolean;

package/dist/collection/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_deriveAll = require("../deriveAll-Cb9rWjan.cjs");
+const require_deriveAll = require("../deriveAll-BQ_p5HSB.cjs");
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
 var TOOL_DEFINITION = {
@@ -769,12 +769,14 @@ exports.errorMessage = errorMessage;
 exports.evaluateDerived = require_deriveAll.evaluateDerived;
 exports.executePresentCollection = executePresentCollection;
 exports.fieldVisible = fieldVisible;
+exports.firstDateField = require_deriveAll.firstDateField;
 exports.firstMissingRequiredField = firstMissingRequiredField;
 exports.isFieldDrivenEvery = require_deriveAll.isFieldDrivenEvery;
 exports.isSortableField = isSortableField;
 exports.itemIdOf = itemIdOf;
 exports.itemLabelOf = itemLabelOf;
 exports.labelFieldFor = labelFieldFor;
+exports.matchesWhere = require_deriveAll.matchesWhere;
 exports.monthAnchorDate = monthAnchorDate;
 exports.nextSortDirection = nextSortDirection;
 exports.numericSortValue = numericSortValue;
@@ -783,8 +785,10 @@ exports.parseIsoDateTime = parseIsoDateTime;
 exports.parseTimeRange = parseTimeRange;
 exports.recordSpan = recordSpan;
 exports.resolveEnumColor = resolveEnumColor;
+exports.resolveIcon = require_deriveAll.resolveIcon;
 exports.resolveRowRefs = require_deriveAll.resolveRowRefs;
 exports.rowFromItem = rowFromItem;
+exports.selectDynamicRecord = require_deriveAll.selectDynamicRecord;
 exports.shortHexId = shortHexId;
 exports.sortItems = sortItems;
 exports.spanCoversDay = spanCoversDay;

package/dist/collection/index.d.ts

@@ -4,6 +4,8 @@ export * from './core/presentCollection';
 export * from './core/enumColors';
 export * from './core/draft';
 export * from './core/actionVisible';
+export * from './core/where';
+export * from './core/dynamicIcon';
 export * from './core/derivedFormula';
 export * from './core/deriveAll';
 export * from './core/sortItems';

package/dist/collection/index.js

@@ -1,4 +1,4 @@
-import { a as FEED_SCHEDULES, c as isFieldDrivenEvery, i as AGENT_INGEST_KIND, n as resolveRowRefs, o as INGEST_KINDS, r as evaluateDerived, s as embedTargetId, t as deriveAll } from "../deriveAll-D3wFH4Tw.js";
+import { a as resolveIcon, c as AGENT_INGEST_KIND, d as embedTargetId, f as isFieldDrivenEvery, i as firstDateField, l as FEED_SCHEDULES, n as resolveRowRefs, o as selectDynamicRecord, r as evaluateDerived, s as matchesWhere, t as deriveAll, u as INGEST_KINDS } from "../deriveAll-CMFXDQ_G.js";
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
 var TOOL_DEFINITION = {
@@ -735,6 +735,6 @@ function defangForPrompt(value) {
 	return value.replace(/[<>]/g, "").replace(/`/g, "'").replace(/\$\{/g, "$ {").replace(/\s+/g, " ").slice(0, DEFANG_MAX_LEN);
 }
 //#endregion
-export { AGENT_INGEST_KIND, ENUM_ALERT, ENUM_NEUTRAL, ENUM_NUDGE, FEED_SCHEDULES, INGEST_KINDS, MINUTES_PER_DAY, TOOL_DEFINITION, TOOL_NAME, actionVisible, assignLanes, boolSortValue, bucketRecords, buildMonthGrid, buildUpdatedRecord, coerceInlineValue, compareSortValues, compareYmd, dateOf, dateSortValue, daySlice, defangForPrompt, deriveAll, draftToRecord, embedTargetId, emptyRow, enumColorClasses, enumSortValue, enumValueIndex, errorMessage, evaluateDerived, executePresentCollection, fieldVisible, firstMissingRequiredField, isFieldDrivenEvery, isSortableField, itemIdOf, itemLabelOf, labelFieldFor, monthAnchorDate, nextSortDirection, numericSortValue, parseIsoDate, parseIsoDateTime, parseTimeRange, recordSpan, resolveEnumColor, resolveRowRefs, rowFromItem, shortHexId, sortItems, spanCoversDay, stringSortValue, whenMatches, ymdKey };
+export { AGENT_INGEST_KIND, ENUM_ALERT, ENUM_NEUTRAL, ENUM_NUDGE, FEED_SCHEDULES, INGEST_KINDS, MINUTES_PER_DAY, TOOL_DEFINITION, TOOL_NAME, actionVisible, assignLanes, boolSortValue, bucketRecords, buildMonthGrid, buildUpdatedRecord, coerceInlineValue, compareSortValues, compareYmd, dateOf, dateSortValue, daySlice, defangForPrompt, deriveAll, draftToRecord, embedTargetId, emptyRow, enumColorClasses, enumSortValue, enumValueIndex, errorMessage, evaluateDerived, executePresentCollection, fieldVisible, firstDateField, firstMissingRequiredField, isFieldDrivenEvery, isSortableField, itemIdOf, itemLabelOf, labelFieldFor, matchesWhere, monthAnchorDate, nextSortDirection, numericSortValue, parseIsoDate, parseIsoDateTime, parseTimeRange, recordSpan, resolveEnumColor, resolveIcon, resolveRowRefs, rowFromItem, selectDynamicRecord, shortHexId, sortItems, spanCoversDay, stringSortValue, whenMatches, ymdKey };
 
 //# sourceMappingURL=index.js.map

package/dist/collection/registry/server/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../../../rolldown-runtime-D6vf50IK.cjs");
-const require_server = require("../../../server-U2d7Fb1h.cjs");
+const require_server = require("../../../server-G6GtOdaW.cjs");
 const require_collection_paths = require("../../paths.cjs");
 const require_types = require("../../../types-CNqkLT4M.cjs");
 const require_skill_bridge_index = require("../../../skill-bridge/index.cjs");

package/dist/collection/registry/server/index.js

@@ -1,4 +1,4 @@
-import { K as collectionsRegistriesConfigPath, L as writeFileAtomic, W as safeRecordId, Y as log, _ as acceptParsedSchema, g as CollectionSchemaZ, m as errorMessage, p as ONE_SECOND_MS, y as loadCollection } from "../../../server-BDxrLT41.js";
+import { G as safeRecordId, R as writeFileAtomic, X as log, _ as CollectionSchemaZ, b as loadCollection, m as errorMessage, p as ONE_SECOND_MS, q as collectionsRegistriesConfigPath, v as acceptParsedSchema } from "../../../server-DKXXFTbw.js";
 import { isSafeActionTemplatePath } from "../../paths.js";
 import { n as parseRegistryIndex, r as isRecord, t as OFFICIAL_REGISTRY_NAME } from "../../../types-BKVZrtyc.js";
 import { claudeSkillDir, dataSkillDir, mirrorSkillWrite } from "../../../skill-bridge/index.js";

package/dist/collection/server/discovery.d.ts

@@ -192,6 +192,57 @@ export declare const CollectionSchemaZ: z.ZodObject<{
         role: z.ZodString;
         template: z.ZodString;
     }, z.core.$strip>], "kind">>;
+    dynamicIcon: z.ZodOptional<z.ZodObject<{
+        source: z.ZodObject<{
+            collection: z.ZodString;
+            from: z.ZodOptional<z.ZodEnum<{
+                latest: "latest";
+                first: "first";
+                when: "when";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodString>;
+            where: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    ne: "ne";
+                    in: "in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+                valueFrom: z.ZodOptional<z.ZodObject<{
+                    record: z.ZodOptional<z.ZodString>;
+                    field: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        rules: z.ZodArray<z.ZodObject<{
+            where: z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    ne: "ne";
+                    in: "in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+                valueFrom: z.ZodOptional<z.ZodObject<{
+                    record: z.ZodOptional<z.ZodString>;
+                    field: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            icon: z.ZodString;
+        }, z.core.$strip>>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /** Result of the post-Zod acceptance gates: the resolved record dir on
  *  success, or a one-line reason discovery would skip the schema. */

package/dist/collection/server/dynamicIcon.d.ts

@@ -0,0 +1,10 @@
+import { DiscoveryOptions } from './discovery';
+import { LoadedCollection } from './discoveredCollection';
+/** Compute the effective launcher icon for `collection`: its static
+ *  `schema.icon` when it declares no `dynamicIcon`, else the icon
+ *  resolved from `dynamicIcon.source`'s RAW stored records (no
+ *  derive/enrich — the icon rules match against stored values) via the
+ *  pure resolver. Fails soft on any read/discovery error (missing source
+ *  collection, filesystem error): falls back to `dynamicIcon.fallback ??
+ *  schema.icon` rather than surfacing to the collections list. */
+export declare function computeCollectionIcon(collection: LoadedCollection, opts?: DiscoveryOptions): Promise<string>;

package/dist/collection/server/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_server = require("../../server-U2d7Fb1h.cjs");
+const require_server = require("../../server-G6GtOdaW.cjs");
 const require_collection_paths = require("../paths.cjs");
 exports.COMPUTED_TYPES = require_server.COMPUTED_TYPES;
 exports.CollectionSchemaZ = require_server.CollectionSchemaZ;
@@ -8,6 +8,7 @@ exports.acceptParsedSchema = require_server.acceptParsedSchema;
 exports.advanceTriggerDate = require_server.advanceTriggerDate;
 exports.buildActionSeedPrompt = require_server.buildActionSeedPrompt;
 exports.buildCollectionActionSeedPrompt = require_server.buildCollectionActionSeedPrompt;
+exports.computeCollectionIcon = require_server.computeCollectionIcon;
 exports.computeSuccessor = require_server.computeSuccessor;
 exports.configureCollectionHost = require_server.configureCollectionHost;
 exports.daysInMonth = require_server.daysInMonth;

package/dist/collection/server/index.d.ts

@@ -6,6 +6,7 @@ export * from './io';
 export * from './validate';
 export * from './discovery';
 export * from './derive';
+export * from './dynamicIcon';
 export * from './spawn';
 export * from './delete';
 export * from './views';

package/dist/collection/server/index.js

@@ -1,3 +1,3 @@
-import { A as promptPathsFor, B as isContainedInWorkspace, C as validateCollectionRecords, D as deleteItem, E as buildCollectionActionSeedPrompt, F as resolveCreateItemId, G as safeSlugName, H as resolveDataDir, I as writeItem, J as getWorkspaceRoot, M as readCustomViewI18n, N as readItem, O as generateItemId, P as readSkillTemplate, R as SCHEMA_FILE, S as COMPUTED_TYPES, T as buildActionSeedPrompt, U as resolveTemplatePath, V as itemFilePath, W as safeRecordId, X as publishCollectionChange, Y as log, Z as setCollectionChangePublisher, _ as acceptParsedSchema, a as computeSuccessor, b as toDetail, c as isTriggerDue, d as resolveEvery, f as successorId, g as CollectionSchemaZ, h as enrichItems, i as advanceTriggerDate, j as readCustomViewHtml, k as listItems, l as maybeSpawnSuccessor, n as deleteCollection, o as daysInMonth, q as configureCollectionHost, r as deleteCollectionRefusalMessage, s as formatCivil, t as deleteCustomView, u as parseCivil, v as discoverCollections, w as validateRecordObject, x as toSummary, y as loadCollection, z as isContainedInRoot } from "../../server-BDxrLT41.js";
+import { A as listItems, B as isContainedInRoot, C as COMPUTED_TYPES, D as buildCollectionActionSeedPrompt, E as buildActionSeedPrompt, F as readSkillTemplate, G as safeRecordId, H as itemFilePath, I as resolveCreateItemId, J as configureCollectionHost, K as safeSlugName, L as writeItem, M as readCustomViewHtml, N as readCustomViewI18n, O as deleteItem, P as readItem, Q as setCollectionChangePublisher, S as toSummary, T as validateRecordObject, U as resolveDataDir, V as isContainedInWorkspace, W as resolveTemplatePath, X as log, Y as getWorkspaceRoot, Z as publishCollectionChange, _ as CollectionSchemaZ, a as computeSuccessor, b as loadCollection, c as isTriggerDue, d as resolveEvery, f as successorId, g as enrichItems, h as computeCollectionIcon, i as advanceTriggerDate, j as promptPathsFor, k as generateItemId, l as maybeSpawnSuccessor, n as deleteCollection, o as daysInMonth, r as deleteCollectionRefusalMessage, s as formatCivil, t as deleteCustomView, u as parseCivil, v as acceptParsedSchema, w as validateCollectionRecords, x as toDetail, y as discoverCollections, z as SCHEMA_FILE } from "../../server-DKXXFTbw.js";
 import { isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath } from "../paths.js";
-export { COMPUTED_TYPES, CollectionSchemaZ, SCHEMA_FILE, acceptParsedSchema, advanceTriggerDate, buildActionSeedPrompt, buildCollectionActionSeedPrompt, computeSuccessor, configureCollectionHost, daysInMonth, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, enrichItems, formatCivil, generateItemId, getWorkspaceRoot, isContainedInRoot, isContainedInWorkspace, isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadCollection, log, maybeSpawnSuccessor, parseCivil, promptPathsFor, publishCollectionChange, readCustomViewHtml, readCustomViewI18n, readItem, readSkillTemplate, resolveCreateItemId, resolveDataDir, resolveEvery, resolveTemplatePath, safeRecordId, safeSlugName, setCollectionChangePublisher, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };
+export { COMPUTED_TYPES, CollectionSchemaZ, SCHEMA_FILE, acceptParsedSchema, advanceTriggerDate, buildActionSeedPrompt, buildCollectionActionSeedPrompt, computeCollectionIcon, computeSuccessor, configureCollectionHost, daysInMonth, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, enrichItems, formatCivil, generateItemId, getWorkspaceRoot, isContainedInRoot, isContainedInWorkspace, isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadCollection, log, maybeSpawnSuccessor, parseCivil, promptPathsFor, publishCollectionChange, readCustomViewHtml, readCustomViewI18n, readItem, readSkillTemplate, resolveCreateItemId, resolveDataDir, resolveEvery, resolveTemplatePath, safeRecordId, safeSlugName, setCollectionChangePublisher, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };

package/dist/collection-watchers/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_collection_index = require("../collection/index.cjs");
-const require_server = require("../server-U2d7Fb1h.cjs");
+const require_server = require("../server-G6GtOdaW.cjs");
 const require_notifier = require("../notifier-bS8IEeLA.cjs");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");

package/dist/collection-watchers/index.js

@@ -1,5 +1,5 @@
 import { whenMatches } from "../collection/index.js";
-import { N as readItem, c as isTriggerDue, k as listItems, l as maybeSpawnSuccessor, v as discoverCollections, y as loadCollection } from "../server-BDxrLT41.js";
+import { A as listItems, P as readItem, b as loadCollection, c as isTriggerDue, l as maybeSpawnSuccessor, y as discoverCollections } from "../server-DKXXFTbw.js";
 import { d as publish, m as updateForPlugin, n as clear, s as listAll } from "../notifier-ChpY0XrY.js";
 import { watch } from "node:fs";
 import { mkdir } from "node:fs/promises";

package/dist/{deriveAll-Cb9rWjan.cjs → deriveAll-BQ_p5HSB.cjs}

@@ -38,6 +38,130 @@ function embedTargetId(field, record) {
 	return "";
 }
 //#endregion
+//#region src/collection/core/where.ts
+/** True when `record[field]` is absent (`undefined`/`null`) — the only case
+*  where `ne` and every other op disagree on the result. */
+function isMissing(raw) {
+	return raw === void 0 || raw === null;
+}
+/** The effective comparison value for `cond`: its literal `value`, or — for
+*  a `valueFrom` reference — the target field read out of `recordsById`.
+*  `undefined` means UNRESOLVED (no such record, or the field on it is
+*  missing); the caller must treat that as "never matches", not as a
+*  literal `undefined` value to compare against. */
+function resolveValue(cond, record, recordsById) {
+	if (!cond.valueFrom) return cond.value;
+	const { record: refRecord, field } = cond.valueFrom;
+	const raw = (refRecord === void 0 ? record : recordsById[refRecord])?.[field];
+	return isMissing(raw) ? void 0 : String(raw);
+}
+function matchesNumericOp(operator, left, right) {
+	if (operator === "gt") return left > right;
+	if (operator === "gte") return left >= right;
+	if (operator === "lt") return left < right;
+	return left <= right;
+}
+/** `Number("")` / `Number("  ")` are `0`, not `NaN`, so treat a blank string
+*  as non-numeric explicitly — an empty field must fail a numeric compare,
+*  not read as zero. */
+function toNumber(raw) {
+	return raw.trim() === "" ? NaN : Number(raw);
+}
+function matchesNumeric(operator, raw, value) {
+	if (Array.isArray(value)) return false;
+	const left = toNumber(raw);
+	const right = toNumber(value);
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return matchesNumericOp(operator, left, right);
+}
+/** True when the present string `raw` satisfies `operator` against the
+*  resolved `value` (field known to exist — MISSING is handled by the
+*  caller before this runs, and an UNRESOLVED `valueFrom` never reaches
+*  here either). */
+function matchesPresent(operator, raw, value) {
+	switch (operator) {
+		case "eq": return raw === String(value);
+		case "ne": return raw !== String(value);
+		case "in": return Array.isArray(value) && value.includes(raw);
+		case "contains": return raw.includes(String(value));
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return matchesNumeric(operator, raw, value);
+		default: return false;
+	}
+}
+/** True when `record` satisfies one condition, given `recordsById` to
+*  resolve a `valueFrom` reference. Two independent MISSING cases, checked
+*  in order:
+*  - `record[cond.field]` absent (`undefined`/`null`) → matches only `ne`
+*    (vacuously true — "not equal to X" holds when there's no value at
+*    all); every other op is false. Unchanged from the literal-`value`
+*    behaviour, regardless of whether `valueFrom` would also resolve.
+*  - the resolved comparison value is UNRESOLVED (a `valueFrom` whose
+*    target record/field doesn't exist) → false for EVERY op, including
+*    `ne` — a broken reference must never spuriously match. */
+function matchesCond(cond, record, recordsById) {
+	const raw = record[cond.field];
+	if (isMissing(raw)) return cond.op === "ne";
+	const value = resolveValue(cond, record, recordsById);
+	if (value === void 0) return false;
+	return matchesPresent(cond.op, String(raw), value);
+}
+/** True when `record` satisfies every condition in `where` (AND). An empty
+*  `where` matches everything. `recordsById` — the source collection's
+*  records keyed by primaryKey — resolves any `valueFrom` reference;
+*  omitted (default `{}`) for callers with no cross-record lookups, in
+*  which case every `valueFrom` condition is UNRESOLVED and so never
+*  matches. */
+function matchesWhere(where, record, recordsById = {}) {
+	return where.every((cond) => matchesCond(cond, record, recordsById));
+}
+//#endregion
+//#region src/collection/core/dynamicIcon.ts
+/** The record with the greatest `String(record[field])` (localeCompare) —
+*  ties keep the first-seen record (stable left-to-right `reduce`). */
+function latestByField(pool, field) {
+	return pool.reduce((latest, candidate) => String(candidate[field] ?? "").localeCompare(String(latest[field] ?? "")) > 0 ? candidate : latest);
+}
+/** Reduce `records` to the one record that decides the effective icon, per
+*  `source`'s `where` filter + `from` strategy:
+*  - pool = `source.where`-filtered records, or every record when unset;
+*  - an empty pool resolves to `null` (no source record → fallback);
+*  - `from: "first"` / `"when"` → the first pool record (storage order);
+*  - `from: "latest"` (default), with `orderBy` given → the pool record
+*    whose `String(record[orderBy])` sorts highest;
+*  - `from: "latest"`, with no `orderBy` → the last pool record.
+*  `recordsById` (the source collection's records keyed by primaryKey)
+*  resolves any `valueFrom` reference inside `source.where`; omitted for
+*  callers with no cross-record lookups. */
+function selectDynamicRecord(records, source, orderBy, recordsById = {}) {
+	const { where } = source;
+	const pool = where ? records.filter((record) => matchesWhere(where, record, recordsById)) : records;
+	if (pool.length === 0) return null;
+	if (source.from === "first" || source.from === "when") return pool[0];
+	return orderBy ? latestByField(pool, orderBy) : pool[pool.length - 1];
+}
+/** Map a resolved source record to the effective icon: `spec.fallback`
+*  (or the collection's own static `icon`) when there's no record or no
+*  rule matches; otherwise the `icon` of the first rule whose `where`
+*  matches the record. `recordsById` resolves any `valueFrom` reference
+*  inside a rule's `where`, same as `selectDynamicRecord`. */
+function resolveIcon(record, spec, staticIcon, recordsById = {}) {
+	const fallback = spec.fallback ?? staticIcon;
+	if (!record) return fallback;
+	const matched = spec.rules.find((rule) => matchesWhere(rule.where, record, recordsById));
+	return matched ? matched.icon : fallback;
+}
+var isDateLikeField = (field) => field.type === "date" || field.type === "datetime";
+/** The first field key (declaration order) whose type is `date` or
+*  `datetime` — the default `orderBy` for `from: "latest"` when a
+*  `DynamicIconSource` doesn't name one. `undefined` when the schema has
+*  no date-like field. */
+function firstDateField(schema) {
+	return Object.entries(schema.fields).find(([, field]) => isDateLikeField(field))?.[0];
+}
+//#endregion
 //#region src/collection/core/derivedFormula.ts
 function evaluateDerived(formula, ctx) {
 	let tokens;
@@ -413,17 +537,41 @@ Object.defineProperty(exports, "evaluateDerived", {
 		return evaluateDerived;
 	}
 });
+Object.defineProperty(exports, "firstDateField", {
+	enumerable: true,
+	get: function() {
+		return firstDateField;
+	}
+});
 Object.defineProperty(exports, "isFieldDrivenEvery", {
 	enumerable: true,
 	get: function() {
 		return isFieldDrivenEvery;
 	}
 });
+Object.defineProperty(exports, "matchesWhere", {
+	enumerable: true,
+	get: function() {
+		return matchesWhere;
+	}
+});
+Object.defineProperty(exports, "resolveIcon", {
+	enumerable: true,
+	get: function() {
+		return resolveIcon;
+	}
+});
 Object.defineProperty(exports, "resolveRowRefs", {
 	enumerable: true,
 	get: function() {
 		return resolveRowRefs;
 	}
 });
+Object.defineProperty(exports, "selectDynamicRecord", {
+	enumerable: true,
+	get: function() {
+		return selectDynamicRecord;
+	}
+});
 
-//# sourceMappingURL=deriveAll-Cb9rWjan.cjs.map
+//# sourceMappingURL=deriveAll-BQ_p5HSB.cjs.map