lorenz 0.1.0

package/extensions/linear-tracker/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAiB,MAAM,gBAAgB,CAAC;AACvE,OAAO,EACL,WAAW,EACX,WAAW,EACX,sBAAsB,GAIvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEhF;;;;GAIG;AACH,MAAM,sBAAsB,GAAG,IAAI,CAAC,OAAO,CACzC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAC5C,IAAI,EACJ,QAAQ,EACR,iBAAiB,CAClB,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAC7B,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAOtC,MAAM,uBAAuB,GAAqB;IAChD,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC;IACxC,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;CAC3C,CAAC;AAEF,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL;YACE,IAAI,EAAE,gBAAgB;YACtB,WAAW,EAAE,gFAAgF;YAC7F,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,oBAAoB,EAAE,KAAK;gBAC3B,UAAU,EAAE;oBACV,KAAK,EAAE;wBACL,IAAI,EAAE,QAAQ;wBACd,WAAW,EAAE,+DAA+D;qBAC7E;oBACD,SAAS,EAAE;wBACT,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;wBACxB,WAAW,EAAE,oCAAoC;wBACjD,oBAAoB,EAAE,IAAI;qBAC3B;iBACF;gBACD,QAAQ,EAAE,CAAC,OAAO,CAAC;aACpB;SACF;KACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAAY,EACZ,KAAc,EACd,QAAkB,EAClB,YAA0B,KAAK;IAE/B,IAAI,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAC9B,OAAO,sBAAsB,CAAC,IAAI,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAC1D,CAAC;IACD,MAAM,eAAe,GAAG,2BAA2B,CAAC,KAAK,CAAC,CAAC;IAC3D,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC;QACxB,OAAO,WAAW,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IACD,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAC7D,IAAI,CAAC,MAAM;QACT,OAAO,WAAW,CAChB,oGAAoG,CACrG,CAAC;IACJ,IACE,eAAe,CAAC,SAAS,KAAK,SAAS;QACvC,eAAe,CAAC,SAAS,KAAK,IAAI;QAClC,CAAC,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,EACpC,CAAC;QACD,OAAO,WAAW,CAAC,iEAAiE,CAAC,CAAC;IACxF,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,uBAAuB,CAAC;QACvC,MAAM,QAAQ,GAAG,MAAM,uBAAuB,CAC5C,SAAS,EACT,EAAE,MAAM,EAAE,QAAQ,EAAE,EACpB,eAAe,CAAC,KAAK,EACrB,eAAe,CAAC,SAAS,IAAI,EAAE,EAC/B,MAAM,CACP,CAAC;QACF,MAAM,UAAU,GAAG,MAAM,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;gBACnF,OAAO,WAAW,CAAC,2CAA2C,QAAQ,CAAC,MAAM,GAAG,EAAE;oBAChF,MAAM,EAAE,QAAQ,CAAC,MAAM;iBACxB,CAAC,CAAC;YACL,CAAC;YACD,OAAO,WAAW,CAAC,wBAAwB,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/E,CAAC;QACD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC7B,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACrE,OAAO,WAAW,CAAC,2CAA2C,QAAQ,CAAC,MAAM,GAAG,EAAE;gBAChF,MAAM,EAAE,QAAQ,CAAC,MAAM;aACxB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3E,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;QAC1C,CAAC;QACD,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,uBAAuB,CAAC,KAAK,CAC3B,kCAAkC,YAAY,CAAC,KAAK,CAAC,GAAG,kBAAkB,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CACpG,CAAC;QACF,OAAO,WAAW,CAAC,uEAAuE,EAAE;YAC1F,MAAM,EAAE,YAAY,CAAC,KAAK,CAAC;SAC5B,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,wFAAwF;AACxF,MAAM,CAAC,MAAM,kBAAkB,GAAiB;IAC9C,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,CAAC,sBAAsB,CAAC;IAChC,eAAe,EAAE,yBAAyB;IAC1C,SAAS,EAAE,GAAG,EAAE,CAAC,eAAe,EAAE;IAClC,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAC1C,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,SAAS,CAAC;CACtE,CAAC;AAEF,SAAS,2BAA2B,CAClC,KAAc;IAId,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;YACrB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,uDAAuD,EAAE,CAAC;QACvF,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACpC,CAAC;IACD,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACxD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,uDAAuD,EAAE,CAAC;IACvF,CAAC;IACD,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;QAC3B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,uDAAuD,EAAE,CAAC;IACvF,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;QAC5F,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,iEAAiE,EAAE,CAAC;IACjG,CAAC;IACD,OAAO;QACL,EAAE,EAAE,IAAI;QACR,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,SAAS,EAAE,KAAK,CAAC,SAA2C;KAC7D,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,uBAAuB,CACpC,SAAuB,EACvB,IAA0C,EAC1C,KAAa,EACb,SAAkC,EAClC,MAAwB;IAExB,KAAK,IAAI,UAAU,GAAG,CAAC,GAAI,UAAU,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE;YAC9C,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC;YACnC,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,aAAa,EAAE,IAAI,CAAC,MAAM;aAC3B;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;SAC3C,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,UAAU,IAAI,kBAAkB;YAAE,OAAO,QAAQ,CAAC;QACjF,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAC3D,MAAM,CAAC,IAAI,CACT,wDAAwD,UAAU,GAAG,CAAC,IAAI,kBAAkB,aAAa,OAAO,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,kBAAkB,CAAC,QAAQ,CAAC,CAAC,EAAE,CACnL,CAAC;QACF,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,OAAgB,EAAE,UAAkB;IACxD,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IAC9C,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1C,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,CAAC;YAAE,OAAO,OAAO,GAAG,IAAI,CAAC;QACrE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,IAAI,UAAU,EAAE,MAAM,CAAC,CAAC;AACnD,CAAC;AAED,KAAK,UAAU,KAAK,CAAC,OAAe;IAClC,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;AAC/D,CAAC;AAED,KAAK,UAAU,gBAAgB,CAC7B,QAAkB;IAElB,IAAI,OAAe,CAAC;IACpB,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IAClC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC;IACD,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,EAAE,CAAC;IAC5D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACvC,CAAC;AACH,CAAC;AAED,KAAK,UAAU,kBAAkB,CAAC,QAAkB;IAClD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;QAC9C,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,CAAC;QACxC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,OAAO,CAAC;QACjB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CACrB,MAAwB,EACxB,KAAa,EACb,MAAc,EACd,IAAa;IAEb,MAAM,CAAC,KAAK,CAAC,wCAAwC,MAAM,GAAG,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;AACnG,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAa,EAAE,IAAc;IACvD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACvC,IAAI,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,aAAa,SAAS,EAAE,CAAC,CAAC;IACpD,IAAI,IAAI,KAAK,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACvE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AACzD,CAAC;AAED,SAAS,aAAa,CAAC,KAAa;IAClC,OAAO,iDAAiD,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AACpF,CAAC;AAED,SAAS,kBAAkB,CAAC,IAAa;IACvC,MAAM,IAAI,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACxE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IACjD,IAAI,OAAO,CAAC,MAAM,IAAI,wBAAwB;QAAE,OAAO,OAAO,CAAC;IAC/D,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,wBAAwB,CAAC,gBAAgB,CAAC;AACvE,CAAC;AAED,SAAS,kBAAkB,CAAC,IAAa;IACvC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;AACH,CAAC"}

package/extensions/linear-tracker/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@lorenz/linear-tracker",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@linear/sdk": "^84.0.0",
+    "@lorenz/domain": "file:../../packages/domain",
+    "@lorenz/issue": "file:../../packages/issue",
+    "@lorenz/tool-sdk": "file:../../packages/tool-sdk",
+    "@lorenz/tracker-sdk": "file:../../packages/tracker-sdk"
+  }
+}

package/extensions/local-tracker/dist/boardStore.d.ts

@@ -0,0 +1,116 @@
+import type { Issue } from "@lorenz/domain";
+/**
+ * Default issue-id prefix. {@link BoardStore} mints ids shaped `<prefix><n>` (see
+ * {@link BoardStore.nextId}); the prefix is configurable per board (tracker.id_prefix) and
+ * defaults to this. Anything not matching `^<prefix>\d+$` - including ids containing path
+ * separators, "..", or NUL - is rejected before it can reach the filesystem, closing off path
+ * traversal via agent-supplied ids.
+ */
+export declare const DEFAULT_ID_PREFIX = "BOARD-";
+/**
+ * The agent-facing read view of a single board issue. Returned by {@link BoardStore.readContent}
+ * so a worker can read back an issue's current status, title, description, AND the comments it (or
+ * the operator) has appended - symmetric with the write tools (updateStatus/appendComment/create).
+ * `comments` is the list of individual "- ..." lines from the issue's "## Comments" section, with
+ * an empty array when the issue has no comments yet.
+ */
+export interface BoardIssueContent {
+    id: string;
+    status: string;
+    title: string;
+    description: string;
+    comments: string[];
+}
+/** A board file that {@link BoardStore.list} could not parse, surfaced rather than hidden. */
+export interface SkippedBoardFile {
+    /** The id derived from the filename (e.g. "BOARD-2"), even if its contents are invalid. */
+    id: string;
+    /** Human-readable reason the file was skipped (missing status, unparseable YAML, etc.). */
+    error: string;
+}
+export interface BoardStoreOptions {
+    /**
+     * Invoked once per board file that fails to parse during a bulk {@link BoardStore.list}
+     * (and the {@link BoardStore.byStatus} / candidate flows built on it). A single bad file is
+     * skipped so it cannot starve the rest of the board, but it is reported here so the problem
+     * is observable instead of silently swallowed. Explicit {@link BoardStore.getByIds} lookups
+     * stay strict and throw rather than routing through this callback.
+     */
+    onSkip?: (skip: SkippedBoardFile) => void;
+    /**
+     * Issue-id prefix for this board (e.g. `"BOARD-"`, `"XXX-"`). Ids are `<prefix><n>`; only
+     * `<prefix><n>.md` files are treated as issues, and new ids are minted with this prefix.
+     * Defaults to {@link DEFAULT_ID_PREFIX}. Must be filesystem-safe (see {@link assertValidIdPrefix});
+     * an invalid prefix throws from the constructor.
+     */
+    idPrefix?: string;
+}
+export declare class BoardStore {
+    private readonly dir;
+    private readonly onSkip;
+    private readonly idPrefix;
+    /** `^<prefix>\d+$` - the canonical id shape this board mints and accepts. */
+    private readonly idPattern;
+    constructor(dir: string, options?: BoardStoreOptions);
+    list(): Promise<Issue[]>;
+    getByIds(ids: string[]): Promise<Issue[]>;
+    byStatus(states: string[]): Promise<Issue[]>;
+    updateStatus(id: string, status: string): Promise<Issue>;
+    appendComment(id: string, body: string, now?: () => Date): Promise<void>;
+    /**
+     * Agent-facing read of a single issue's content: its current status, title, description, and the
+     * comments appended to it. Symmetric with the write methods so a worker can read back what it (or
+     * the operator) wrote. Validates the id and reads/parses the file via the same parse() the write
+     * paths use, so a missing/invalid id throws exactly as getByIds/updateStatus do. The "## Comments"
+     * block is split into individual "- ..." entries (empty array when the issue has no comments).
+     */
+    readContent(id: string): Promise<BoardIssueContent>;
+    create(input: {
+        title: string;
+        body?: string;
+        status?: string;
+    }): Promise<Issue>;
+    /**
+     * Create the board directory durably so a freshly-created board survives a crash. mkdir alone
+     * is not enough: fsyncing this.dir after publishing a file persists the entries INSIDE it, but
+     * NOT the directory entry in the PARENT that makes a newly-created board dir reachable. On a
+     * first-run board (the .symphony/local path did not exist) a crash right after create() could
+     * otherwise lose the entire new directory and the acknowledged issue even though the file and
+     * the board dir were synced.
+     *
+     * fs.mkdir(dir, { recursive: true }) returns the path of the FIRST (topmost) directory it
+     * actually created, or undefined when nothing was created (the dir already existed). When it
+     * created something, every directory along the chain from that topmost-created dir down to (and
+     * including) this.dir is brand new, and each gained a new child entry in its own parent. To make
+     * the whole chain reachable we fsync each parent that gained a new entry: path.dirname(topmost)
+     * (the pre-existing parent that gained the top new dir) plus every newly-created directory from
+     * the topmost down to - but NOT including - this.dir (this.dir's own entry is fsynced by the
+     * existing post-publish fsyncDir(this.dir), which persists the new FILE entry inside it). When
+     * nothing was created (dir already existed) there is no parent entry to flush. fsyncDir is
+     * best-effort (it swallows dir-fsync-unsupported errors), so platforms that cannot fsync a dir
+     * handle are unaffected.
+     */
+    private ensureBoardDir;
+    private filePath;
+    private issueIds;
+    private nextId;
+    private read;
+    private parse;
+    private render;
+    /**
+     * Atomic replace: write to a uniquely-named sibling temp file in the SAME directory and
+     * fs.rename it over the target. rename is atomic within a filesystem, so a crash mid-write
+     * leaves either the prior file or the fully-written new file intact - never a truncated one.
+     * The contents are fsync'd before the rename and the directory after it, so the rename cannot
+     * expose a name whose data has not yet reached disk (which would otherwise read back empty).
+     */
+    private write;
+    /** Reject any id not matching this board's `^<prefix>\d+$` (defends agent-supplied ids). */
+    private assertValidId;
+    /**
+     * Numeric suffix of a canonical id (e.g. "XXX-7" -> 7). Callers pass ids that already matched
+     * idPattern, so the slice after the prefix is always digits; the fallback is belt-and-suspenders.
+     */
+    private boardNumber;
+}
+//# sourceMappingURL=boardStore.d.ts.map

package/extensions/local-tracker/dist/boardStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boardStore.d.ts","sourceRoot":"","sources":["../src/boardStore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAmB5C;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,WAAW,CAAC;AA6G1C;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,8FAA8F;AAC9F,MAAM,WAAW,gBAAgB;IAC/B,2FAA2F;IAC3F,EAAE,EAAE,MAAM,CAAC;IACX,2FAA2F;IAC3F,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,UAAU;IAOnB,OAAO,CAAC,QAAQ,CAAC,GAAG;IANtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiD;IACxE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGhB,GAAG,EAAE,MAAM,EAC5B,OAAO,GAAE,iBAAsB;IAQ3B,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;IAexB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAQzC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAK5C,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAiBxD,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,IAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYhG;;;;;;OAMG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAanD,MAAM,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,KAAK,CAAC;IAwEtF;;;;;;;;;;;;;;;;;;;OAmBG;YACW,cAAc;IAsB5B,OAAO,CAAC,QAAQ;YAWF,QAAQ;YAgCR,MAAM;YAMN,IAAI;YAmBJ,KAAK;IAYnB,OAAO,CAAC,MAAM;IAUd;;;;;;OAMG;YACW,KAAK;IAenB,4FAA4F;IAC5F,OAAO,CAAC,aAAa;IAQrB;;;OAGG;IACH,OAAO,CAAC,WAAW;CAIpB"}

package/extensions/local-tracker/dist/boardStore.js

@@ -0,0 +1,475 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { defaultStateType, normalizeIssue } from "@lorenz/issue";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+/**
+ * Collision-resistant sentinel that marks the start of the comments section. It sits
+ * immediately before the human-readable "## Comments" heading so a description that
+ * legitimately contains a "## Comments" heading is never misparsed.
+ */
+const COMMENTS_MARKER = "<!-- symphony:comments -->";
+/**
+ * Default issue-id prefix. {@link BoardStore} mints ids shaped `<prefix><n>` (see
+ * {@link BoardStore.nextId}); the prefix is configurable per board (tracker.id_prefix) and
+ * defaults to this. Anything not matching `^<prefix>\d+$` - including ids containing path
+ * separators, "..", or NUL - is rejected before it can reach the filesystem, closing off path
+ * traversal via agent-supplied ids.
+ */
+export const DEFAULT_ID_PREFIX = "BOARD-";
+/**
+ * Valid id prefixes: an alphanumeric, then alphanumerics / `_` / `-`. Disallowing `.`, `/`, `\`,
+ * whitespace and NUL keeps every minted filename inside the board dir (no traversal) and keeps
+ * `<prefix><n>` an unambiguous, safe filename stem. The trailing `-` in "BOARD-" is allowed.
+ */
+const ID_PREFIX_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+/** Escape a string for safe literal interpolation into a RegExp (the configured prefix). */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Throw if `prefix` is not a safe id prefix (letters/digits, then letters/digits/`_`/`-`). */
+function assertValidIdPrefix(prefix) {
+    if (!ID_PREFIX_PATTERN.test(prefix)) {
+        throw new Error(`invalid board id_prefix: ${JSON.stringify(prefix)} ` +
+            `(must start alphanumeric, then only letters, digits, "_" or "-")`);
+    }
+}
+/**
+ * Module-level (process-wide) lock chain keyed by an absolute filesystem path. Because
+ * {@link BoardStore} is rebuilt per MCP call (see storeFor), the mutex MUST live at module
+ * scope so every instance pointing at the same board file/dir shares the same chain.
+ *
+ * Each key maps to a promise that resolves when the currently-queued critical sections for
+ * that key have finished. {@link withLock} appends its work to the chain so read-modify-write
+ * cycles on the same file (or id allocation in the same dir) serialize instead of interleaving
+ * and losing an update. This is IN-PROCESS serialization only: it covers concurrent agents and
+ * ensemble slots inside the single Symphony daemon, but assumes no external process is editing
+ * the board files concurrently (that is out of scope - see ts/README.md).
+ */
+const pathLocks = new Map();
+/**
+ * Force a file's CONTENTS to durable storage. The temp/rename and temp/link publish dances are
+ * only crash-atomic if the new file's data blocks reach disk BEFORE the directory entry that
+ * exposes them: otherwise a power-loss can leave a published BOARD-<n>.md whose name is visible
+ * but whose contents are still buffered (zero-length or truncated) - the exact "empty/partial
+ * file" failure the atomic publish is meant to prevent. fsync the data first, then the dir entry.
+ */
+async function fsyncFile(filePath) {
+    const fh = await fs.open(filePath, "r");
+    try {
+        await fh.sync();
+    }
+    finally {
+        await fh.close();
+    }
+}
+/**
+ * Force a DIRECTORY entry to durable storage so a freshly-published (renamed/linked) file is
+ * guaranteed to survive a crash. Directory fsync is a best-effort durability barrier: some
+ * platforms (notably Windows) cannot fsync a directory handle and reject with EINVAL/EISDIR/
+ * EPERM/EBADF/ENOTSUP/EACCES. Those are swallowed - the data fsync above already protects the
+ * contents, and the OS will flush the entry on its own schedule - but unexpected errors propagate.
+ */
+async function fsyncDir(dirPath) {
+    let fh;
+    try {
+        fh = await fs.open(dirPath, "r");
+    }
+    catch (err) {
+        if (isUnsupportedDirSync(err.code))
+            return;
+        throw err;
+    }
+    try {
+        await fh.sync();
+    }
+    catch (err) {
+        if (!isUnsupportedDirSync(err.code))
+            throw err;
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** Platforms that cannot fsync a directory handle reject with one of these; treat as a no-op. */
+function isUnsupportedDirSync(code) {
+    return (code === "EINVAL" ||
+        code === "EISDIR" ||
+        code === "EPERM" ||
+        code === "EBADF" ||
+        code === "ENOTSUP" ||
+        code === "EACCES");
+}
+async function withLock(key, fn) {
+    const prior = pathLocks.get(key) ?? Promise.resolve();
+    // Run fn after the prior holder settles. Always continue (.then with both handlers) so one
+    // critical section's failure cannot poison the next caller's turn.
+    const run = prior.then(fn, fn);
+    // The tail is what later callers wait on; its settled value/error is intentionally discarded.
+    const tail = run.then(() => undefined, () => undefined);
+    pathLocks.set(key, tail);
+    try {
+        return await run;
+    }
+    finally {
+        // Once this is the last queued work for the key, drop it so the Map cannot grow unbounded.
+        if (pathLocks.get(key) === tail)
+            pathLocks.delete(key);
+    }
+}
+export class BoardStore {
+    dir;
+    onSkip;
+    idPrefix;
+    /** `^<prefix>\d+$` - the canonical id shape this board mints and accepts. */
+    idPattern;
+    constructor(dir, options = {}) {
+        this.dir = dir;
+        this.onSkip = options.onSkip;
+        this.idPrefix = options.idPrefix ?? DEFAULT_ID_PREFIX;
+        assertValidIdPrefix(this.idPrefix);
+        this.idPattern = new RegExp(`^${escapeRegExp(this.idPrefix)}\\d+$`);
+    }
+    async list() {
+        const ids = await this.issueIds();
+        const out = [];
+        for (const id of ids) {
+            try {
+                out.push(await this.read(id));
+            }
+            catch (err) {
+                // One malformed/unreadable file must not abort the whole listing (and, via the
+                // runtime, the poll). Skip it but surface the reason through onSkip so it is visible.
+                this.onSkip?.({ id, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+        return out;
+    }
+    async getByIds(ids) {
+        for (const id of ids)
+            this.assertValidId(id);
+        const existing = new Set(await this.issueIds());
+        const out = [];
+        for (const id of ids)
+            if (existing.has(id))
+                out.push(await this.read(id));
+        return out;
+    }
+    async byStatus(states) {
+        const wanted = new Set(states.map((s) => s.trim().toLowerCase()));
+        return (await this.list()).filter((i) => wanted.has(i.state.trim().toLowerCase()));
+    }
+    async updateStatus(id, status) {
+        this.assertValidId(id);
+        const trimmed = status.trim();
+        // Reject an empty/whitespace-only status BEFORE writing: a blank status produces a file
+        // that parse() rejects as "missing required 'status'", which would silently drop the issue
+        // from list(). Failing fast here leaves the file (and its prior status) intact.
+        if (trimmed === "")
+            throw new Error(`board issue ${id} status must not be empty`);
+        // Serialize the read-modify-write per target file (module-level lock) so a concurrent
+        // appendComment/updateStatus on the same issue cannot read-then-clobber and lose an update.
+        return withLock(this.filePath(id), async () => {
+            const parsed = await this.parse(id);
+            parsed.status = trimmed;
+            await this.write(id, parsed);
+            return this.read(id);
+        });
+    }
+    async appendComment(id, body, now = () => new Date()) {
+        this.assertValidId(id);
+        // Same per-file lock as updateStatus: the parse -> append -> write cycle must be atomic with
+        // respect to other mutations of this issue, otherwise concurrent comments overwrite each other.
+        await withLock(this.filePath(id), async () => {
+            const parsed = await this.parse(id);
+            const line = `- ${now().toISOString()} agent: ${body}`;
+            parsed.comments = parsed.comments ? `${parsed.comments}\n${line}` : line;
+            await this.write(id, parsed);
+        });
+    }
+    /**
+     * Agent-facing read of a single issue's content: its current status, title, description, and the
+     * comments appended to it. Symmetric with the write methods so a worker can read back what it (or
+     * the operator) wrote. Validates the id and reads/parses the file via the same parse() the write
+     * paths use, so a missing/invalid id throws exactly as getByIds/updateStatus do. The "## Comments"
+     * block is split into individual "- ..." entries (empty array when the issue has no comments).
+     */
+    async readContent(id) {
+        this.assertValidId(id);
+        const parsed = await this.parse(id);
+        const comments = parsed.comments.trim() === "" ? [] : parsed.comments.split("\n");
+        return {
+            id,
+            status: parsed.status,
+            title: parsed.title,
+            description: parsed.description,
+            comments,
+        };
+    }
+    async create(input) {
+        const status = input.status === undefined ? "Todo" : input.status.trim();
+        if (status === "")
+            throw new Error("board issue status must not be empty");
+        const parsed = {
+            status,
+            labels: [],
+            title: input.title,
+            description: input.body ?? "",
+            comments: "",
+        };
+        const contents = this.render(parsed);
+        // Serialize id allocation per board DIRECTORY under the same module-level lock so concurrent
+        // creates in one daemon do not all scan the same nextId in lockstep. The no-overwrite link
+        // below is still the authoritative guard (it also defends against any external writer), so the
+        // lock is an optimization that also keeps the bounded retry loop from churning.
+        return withLock(path.resolve(this.dir), async () => {
+            // ensureBoardDir MUST run inside the per-directory lock. On a first-run board the chain is
+            // created by mkdir(recursive), and fs.mkdir returns only the topmost level THIS call observed
+            // as newly-created. Two concurrent first-run creates can interleave inside Node's recursive
+            // mkdir so each sees a different topmost-created level and fsyncs only its own slice of the
+            // chain - with no happens-before barrier guaranteeing the slice covering the upper parents is
+            // durable before the other caller publishes its file. Serializing ensureBoardDir under the
+            // same lock as the publish makes exactly one create build AND fully fsync the new chain before
+            // any racing create observes the dir as existing (mkdir returns undefined) and links its file.
+            await this.ensureBoardDir();
+            // Crash-atomic publish: write the full contents to a sibling TEMP file first, then PUBLISH
+            // it to the final BOARD-<n>.md with a no-overwrite hard link. fs.link is atomic and fails
+            // with EEXIST if the target already exists, so it is collision-safe (two racing creates can
+            // never pick the same BOARD-<n>, and an external writer is still defended against) AND
+            // crash-safe (a process death mid-write leaves only the ignored temp, never a truncated
+            // <prefix><n>.md - issueIds() filters to ^<prefix>\d+$ so the dotted temp is invisible). On
+            // EEXIST we recompute nextId and retry the link, reusing the same fully-written temp file.
+            //
+            // The temp name is NOT a "<prefix><n>.md" stem (it is dotted and ends in .tmp) so it is never
+            // mistaken for an issue; the id is not part of the name because one temp serves every retry.
+            const tmp = path.join(this.dir, `.symphony-create.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`);
+            try {
+                await fs.writeFile(tmp, contents, "utf8");
+                // Flush the temp's CONTENTS to disk before publishing its directory entry. Otherwise a
+                // crash after fs.link could leave a named BOARD-<n>.md whose data is still buffered (i.e.
+                // an empty/partial file) - the very failure the temp+link publish is meant to rule out.
+                await fsyncFile(tmp);
+                // Allocate an id with a no-overwrite link so two racing creates can never publish over the
+                // same BOARD-<n>. On collision (EEXIST) we recompute the next id and retry within a bounded
+                // loop rather than blindly overwriting an existing issue file.
+                const attempts = 64;
+                for (let attempt = 0; attempt < attempts; attempt++) {
+                    const id = await this.nextId();
+                    const target = this.filePath(id);
+                    try {
+                        await fs.link(tmp, target);
+                    }
+                    catch (err) {
+                        if (err.code === "EEXIST")
+                            continue;
+                        throw err;
+                    }
+                    // The new directory entry must itself be durable, or a crash could lose the just-linked
+                    // name even though its (already-fsynced) contents are safe. Flush the dir, then read back.
+                    await fsyncDir(this.dir);
+                    return await this.read(id);
+                }
+                throw new Error(`failed to allocate a board id after ${attempts} attempts`);
+            }
+            finally {
+                // Always drop the temp (success or failure). A leftover is harmless - issueIds() ignores
+                // it - but removing it keeps the board dir clean. force:true so a never-created temp is fine.
+                await fs.rm(tmp, { force: true }).catch(() => { });
+            }
+        });
+    }
+    /**
+     * Create the board directory durably so a freshly-created board survives a crash. mkdir alone
+     * is not enough: fsyncing this.dir after publishing a file persists the entries INSIDE it, but
+     * NOT the directory entry in the PARENT that makes a newly-created board dir reachable. On a
+     * first-run board (the .symphony/local path did not exist) a crash right after create() could
+     * otherwise lose the entire new directory and the acknowledged issue even though the file and
+     * the board dir were synced.
+     *
+     * fs.mkdir(dir, { recursive: true }) returns the path of the FIRST (topmost) directory it
+     * actually created, or undefined when nothing was created (the dir already existed). When it
+     * created something, every directory along the chain from that topmost-created dir down to (and
+     * including) this.dir is brand new, and each gained a new child entry in its own parent. To make
+     * the whole chain reachable we fsync each parent that gained a new entry: path.dirname(topmost)
+     * (the pre-existing parent that gained the top new dir) plus every newly-created directory from
+     * the topmost down to - but NOT including - this.dir (this.dir's own entry is fsynced by the
+     * existing post-publish fsyncDir(this.dir), which persists the new FILE entry inside it). When
+     * nothing was created (dir already existed) there is no parent entry to flush. fsyncDir is
+     * best-effort (it swallows dir-fsync-unsupported errors), so platforms that cannot fsync a dir
+     * handle are unaffected.
+     */
+    async ensureBoardDir() {
+        const firstCreated = await fs.mkdir(this.dir, { recursive: true });
+        if (!firstCreated)
+            return;
+        // Every directory that gained a NEW child entry along the freshly-created chain must be
+        // fsynced so the chain is reachable. Those are exactly the parents of each newly-created
+        // directory: path.dirname(top) (the pre-existing dir that gained `top`) through to
+        // path.dirname(this.dir) (the last new dir above this.dir). We walk UP from this.dir's parent
+        // and stop after flushing path.dirname(top). this.dir itself is intentionally skipped - its
+        // own entry is persisted by the post-publish fsyncDir(this.dir) that flushes the new file.
+        const top = path.resolve(firstCreated);
+        const stop = path.dirname(top);
+        let parent = path.dirname(path.resolve(this.dir));
+        // Guard against an unexpected loop at a filesystem root (path.dirname("/") === "/").
+        while (true) {
+            await fsyncDir(parent);
+            if (parent === stop)
+                break;
+            const next = path.dirname(parent);
+            if (next === parent)
+                break;
+            parent = next;
+        }
+    }
+    filePath(id) {
+        this.assertValidId(id);
+        const resolved = path.resolve(this.dir, `${id}.md`);
+        // Defense in depth: even with a valid-looking id, refuse any path that escapes the board dir.
+        const base = path.resolve(this.dir);
+        if (resolved !== path.join(base, `${id}.md`) || !resolved.startsWith(base + path.sep)) {
+            throw new Error(`invalid board issue id: ${JSON.stringify(id)}`);
+        }
+        return resolved;
+    }
+    async issueIds() {
+        let entries;
+        try {
+            entries = await fs.readdir(this.dir);
+        }
+        catch (err) {
+            // A MISSING board directory is a legitimately empty board: return [] so list()/byStatus()/
+            // fetchCandidateIssues report no issues. But any OTHER failure (EACCES on a locked-down dir,
+            // ENOTDIR when the path points at a file, etc.) means the board is misconfigured or broken,
+            // and silently returning [] would make it look idle - hiding the operator action needed.
+            // Re-throw with the dir in the message so the runtime poll-loop guard records a poll_error
+            // (it catches throws from fetchCandidateIssues, logs, and keeps the daemon alive) instead of
+            // swallowing the failure.
+            if (err.code === "ENOENT")
+                return [];
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new Error(`failed to read board directory ${JSON.stringify(this.dir)}: ${reason}`, {
+                cause: err,
+            });
+        }
+        return (entries
+            .filter((f) => f.endsWith(".md"))
+            .map((f) => f.slice(0, -3))
+            // Keep ONLY canonical board ids (the same shape filePath/assertValidId enforce). Stray
+            // markdown files (README.md, notes.md) and files with a different prefix are not board
+            // issues, so ignoring them here keeps list()/getByIds()/byStatus() clean AND prevents
+            // nextId() from feeding a non-matching stem into boardNumber() (whose MAX_SAFE_INTEGER
+            // fallback would otherwise blow up id allocation).
+            .filter((id) => this.idPattern.test(id))
+            .sort((a, b) => this.boardNumber(a) - this.boardNumber(b)));
+    }
+    async nextId() {
+        let max = 0;
+        for (const id of await this.issueIds())
+            max = Math.max(max, this.boardNumber(id));
+        return `${this.idPrefix}${max + 1}`;
+    }
+    async read(id) {
+        const parsed = await this.parse(id);
+        const stat = await fs.stat(this.filePath(id));
+        // normalizeIssue requires a stateType. Map known statuses and fall back to "backlog"
+        // for custom/free-form board statuses so an unrecognized status never crashes the read.
+        const stateType = defaultStateType(parsed.status) ?? "backlog";
+        return normalizeIssue({
+            id,
+            identifier: id,
+            title: parsed.title.trim() === "" ? id : parsed.title,
+            description: parsed.description === "" ? null : parsed.description,
+            state: parsed.status,
+            state_type: stateType,
+            labels: parsed.labels,
+            created_at: stat.birthtime.toISOString(),
+            updated_at: stat.mtime.toISOString(),
+        });
+    }
+    async parse(id) {
+        const raw = (await fs.readFile(this.filePath(id), "utf8")).replace(/\r\n/g, "\n");
+        const { frontmatter, body } = splitFrontmatter(raw);
+        const fm = (frontmatter ? parseYaml(frontmatter) : {});
+        const status = typeof fm.status === "string" ? fm.status.trim() : "";
+        if (status === "")
+            throw new Error(`board issue ${id} is missing required 'status'`);
+        const labels = Array.isArray(fm.labels)
+            ? fm.labels.filter((l) => typeof l === "string")
+            : [];
+        return { status, labels, ...splitBody(body) };
+    }
+    render(p) {
+        const fm = { status: p.status };
+        if (p.labels.length > 0)
+            fm.labels = p.labels;
+        const sections = [`---\n${stringifyYaml(fm).trimEnd()}\n---`, `# ${p.title}`];
+        if (p.description.trim() !== "")
+            sections.push(p.description.trim());
+        if (p.comments.trim() !== "")
+            sections.push(`${COMMENTS_MARKER}\n## Comments\n${p.comments.trim()}`);
+        return `${sections.join("\n\n")}\n`;
+    }
+    /**
+     * Atomic replace: write to a uniquely-named sibling temp file in the SAME directory and
+     * fs.rename it over the target. rename is atomic within a filesystem, so a crash mid-write
+     * leaves either the prior file or the fully-written new file intact - never a truncated one.
+     * The contents are fsync'd before the rename and the directory after it, so the rename cannot
+     * expose a name whose data has not yet reached disk (which would otherwise read back empty).
+     */
+    async write(id, p) {
+        await this.ensureBoardDir();
+        const target = this.filePath(id);
+        const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+        try {
+            await fs.writeFile(tmp, this.render(p), "utf8");
+            await fsyncFile(tmp);
+            await fs.rename(tmp, target);
+            await fsyncDir(this.dir);
+        }
+        catch (err) {
+            await fs.rm(tmp, { force: true }).catch(() => { });
+            throw err;
+        }
+    }
+    /** Reject any id not matching this board's `^<prefix>\d+$` (defends agent-supplied ids). */
+    assertValidId(id) {
+        if (!this.idPattern.test(id)) {
+            throw new Error(`invalid board issue id: ${JSON.stringify(id)} (expected ${this.idPrefix}<n>)`);
+        }
+    }
+    /**
+     * Numeric suffix of a canonical id (e.g. "XXX-7" -> 7). Callers pass ids that already matched
+     * idPattern, so the slice after the prefix is always digits; the fallback is belt-and-suspenders.
+     */
+    boardNumber(id) {
+        const n = Number(id.slice(this.idPrefix.length));
+        return Number.isInteger(n) ? n : Number.MAX_SAFE_INTEGER;
+    }
+}
+function splitFrontmatter(raw) {
+    if (!raw.startsWith("---"))
+        return { frontmatter: null, body: raw };
+    const end = raw.indexOf("\n---", 3);
+    if (end === -1)
+        return { frontmatter: null, body: raw };
+    const frontmatter = raw.slice(raw.indexOf("\n") + 1, end);
+    const afterClose = raw.indexOf("\n", end + 1);
+    const body = afterClose === -1 ? "" : raw.slice(afterClose + 1);
+    return { frontmatter, body };
+}
+function splitBody(body) {
+    const markerIdx = body.indexOf(COMMENTS_MARKER);
+    const main = markerIdx === -1 ? body : body.slice(0, markerIdx);
+    const comments = markerIdx === -1
+        ? ""
+        : body
+            .slice(markerIdx + COMMENTS_MARKER.length)
+            .replace(/^\n?## Comments\n?/, "")
+            .trim();
+    const lines = main.split("\n");
+    const headingIdx = lines.findIndex((l) => l.startsWith("# "));
+    const title = headingIdx === -1 ? "" : lines[headingIdx].slice(2).trim();
+    const descLines = headingIdx === -1 ? lines : lines.slice(headingIdx + 1);
+    return { title, description: descLines.join("\n").trim(), comments };
+}
+//# sourceMappingURL=boardStore.js.map