@nestos/kanban 0.0.0-stage → 0.5.2

package/dist/chunk-VMRDXOLX.cjs

@@ -0,0 +1,148 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkEYTVC2H5cjs = require('./chunk-EYTVC2H5.cjs');
+
+
+var _chunkRSH6QSECcjs = require('./chunk-RSH6QSEC.cjs');
+
+// src/store.ts
+var _vfscore = require('@nestos/vfs-core');
+var SeqKanbanStore = class _SeqKanbanStore {
+  constructor(fs, path, bodies) {
+    this.fs = fs;
+    this.path = path;
+    this.bodies = _nullishCoalesce(bodies, () => ( { read: async (hash) => {
+      const body = await fs.meta.assets.getAsset(path, `${hash}.json`);
+      if (body === null || body instanceof ArrayBuffer) return body;
+      throw new (0, _chunkRSH6QSECcjs.KanbanError)("BODY_INTEGRITY");
+    }, write: async (hash, bytes) => {
+      await fs.meta.assets.putAsset(path, `${hash}.json`, bytes);
+    } }));
+  }
+  
+  static async open(fs, directory = "/kanban", bodies) {
+    if (!_optionalChain([fs, 'access', _2 => _2.meta, 'access', _3 => _3.seq, 'optionalAccess', _4 => _4.transaction])) throw new (0, _chunkRSH6QSECcjs.KanbanError)("TRANSACTION_REQUIRED");
+    try {
+      await fs.driver.createFile({ parentPath: directory, name: "boards.seq", type: "seqfile", recursive: true });
+    } catch (error) {
+      if (!(error instanceof _vfscore.FSError) || error.code !== "EEXIST") throw error;
+    }
+    return new _SeqKanbanStore(fs, `${directory}/boards.seq`, bodies);
+  }
+  async boardId(number) {
+    return this.fs.meta.seq.getEntry(this.path, _chunkEYTVC2H5cjs.boardNumberKey.call(void 0, number));
+  }
+  async ids() {
+    return JSON.parse(await _asyncNullishCoalesce(await this.fs.meta.seq.getEntry(this.path, "index"), async () => ( "[]")));
+  }
+  async events(id, after, limit, through) {
+    const end = Math.min(through, after + limit);
+    const keys = Array.from({ length: Math.max(0, end - after) }, (_, index) => `event/${encodeURIComponent(id)}/${String(after + index + 1).padStart(16, "0")}`);
+    if (!keys.length) return [];
+    const rows = await this.fs.meta.seq.getEntries(this.path, keys);
+    return keys.filter((key) => rows[key] !== void 0).map((key) => JSON.parse(rows[key]));
+  }
+  async archived(boardId, itemId) {
+    const raw = await this.fs.meta.seq.getEntry(this.path, _chunkEYTVC2H5cjs.archiveKey.call(void 0, boardId, itemId));
+    if (!raw) return null;
+    const record = await _chunkEYTVC2H5cjs.decodeRow.call(void 0, raw, this.bodies);
+    record.item.number ??= await _asyncOptionalChain([(await this.view(boardId)), 'optionalAccess', async _5 => _5.state, 'access', async _6 => _6.archiveIndex, 'optionalAccess', async _7 => _7.find, 'call', async _8 => _8((item) => item.id === itemId), 'optionalAccess', async _9 => _9.number]);
+    return record;
+  }
+  async load(id, receiptKey) {
+    return this.fs.meta.seq.transaction(async (tx) => {
+      const raw = await tx.getEntry(this.path, _chunkEYTVC2H5cjs.boardKey.call(void 0, id));
+      return { raw, rows: await tx.getEntries(this.path, _chunkEYTVC2H5cjs.rowKeys.call(void 0, raw)), receipt: receiptKey ? await tx.getEntry(this.path, receiptKey) : void 0 };
+    });
+  }
+  async view(id) {
+    const raw = await this.fs.meta.seq.getEntry(this.path, _chunkEYTVC2H5cjs.boardKey.call(void 0, id));
+    const indexed = _chunkEYTVC2H5cjs.indexedView.call(void 0, raw);
+    if (indexed) return indexed;
+    const state = await this.read(id);
+    return state ? _chunkEYTVC2H5cjs.viewFromState.call(void 0, state) : null;
+  }
+  async read(id) {
+    return _chunkEYTVC2H5cjs.hydrate.call(void 0, await this.load(id), this.bodies);
+  }
+  async update(id, operationId, fingerprint, change) {
+    const receiptKey = `receipt/${encodeURIComponent(id)}/${encodeURIComponent(operationId)}`;
+    const before = await this.load(id, receiptKey), current = await _chunkEYTVC2H5cjs.hydrate.call(void 0, before, this.bodies), receipt = before.receipt;
+    if (receipt) {
+      _chunkEYTVC2H5cjs.verifyReceipt.call(void 0, receipt, fingerprint);
+      if (!current) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CORRUPT_RECEIPT");
+      return current;
+    }
+    const original = JSON.stringify(current), next = change(current);
+    _chunkEYTVC2H5cjs.numberEntities.call(void 0, next);
+    if (JSON.stringify(next) === original) return next;
+    return this.persist(id, receiptKey, fingerprint, before, next);
+  }
+  async persist(id, receiptKey, fingerprint, before, next) {
+    const events = [...next.events], archives = await Promise.all((_nullishCoalesce(next.archiveWrites, () => ( []))).map(async (write) => ({ key: _chunkEYTVC2H5cjs.archiveKey.call(void 0, id, write.id), value: write.value ? await _chunkEYTVC2H5cjs.encodeRow.call(void 0, write.value, this.bodies) : null })));
+    delete next.archiveWrites;
+    next.events = [];
+    const encoded = await _chunkEYTVC2H5cjs.encodeBoard.call(void 0, next, this.bodies);
+    const committed = await this.fs.meta.seq.transaction(async (tx) => {
+      const latestReceipt = await tx.getEntry(this.path, receiptKey);
+      if (latestReceipt) {
+        _chunkEYTVC2H5cjs.verifyReceipt.call(void 0, latestReceipt, fingerprint);
+        return null;
+      }
+      if (await tx.getEntry(this.path, _chunkEYTVC2H5cjs.boardKey.call(void 0, id)) !== before.raw) throw new (0, _chunkRSH6QSECcjs.KanbanError)("REVISION_CONFLICT");
+      await commitBoardNumber(tx, this.path, id, before, next, encoded);
+      const eventRows = events.map((event) => ({ key: `event/${encodeURIComponent(id)}/${String(event.sequence).padStart(16, "0")}`, value: JSON.stringify(event) }));
+      await writeRows(tx, this.path, [
+        ...eventRows,
+        ..._chunkEYTVC2H5cjs.rowChanges.call(void 0, before, encoded),
+        ...archives,
+        { key: _chunkEYTVC2H5cjs.boardKey.call(void 0, id), value: encoded.raw },
+        { key: receiptKey, value: _chunkEYTVC2H5cjs.receiptDigest.call(void 0, fingerprint) }
+      ]);
+      const ids = JSON.parse(await _asyncNullishCoalesce(await tx.getEntry(this.path, "index"), async () => ( "[]")));
+      if (!ids.includes(id)) await tx.setEntry(this.path, "index", JSON.stringify([...ids, id]));
+      return next;
+    });
+    if (committed) return committed;
+    const replay = await this.read(id);
+    if (!replay) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CORRUPT_RECEIPT");
+    return replay;
+  }
+};
+async function writeRows(tx, path, rows) {
+  for (const row of rows) {
+    if (row.value === null) await tx.deleteEntry(path, row.key);
+    else await tx.setEntry(path, row.key, row.value);
+  }
+}
+async function commitBoardNumber(tx, path, id, before, next, encoded) {
+  const previous = _chunkEYTVC2H5cjs.counter.call(void 0, await tx.getEntry(path, _chunkEYTVC2H5cjs.boardCounterKey));
+  next.board.number = _chunkEYTVC2H5cjs.allocateBoardNumber.call(void 0, before.raw, previous);
+  const owner = await tx.getEntry(path, _chunkEYTVC2H5cjs.boardNumberKey.call(void 0, next.board.number));
+  if (owner !== null && owner !== id) throw new (0, _chunkRSH6QSECcjs.KanbanError)("INVALID_NUMBERING");
+  encoded.raw = _chunkEYTVC2H5cjs.patchBoardNumber.call(void 0, encoded.raw, next.board.number);
+  await tx.setEntry(path, _chunkEYTVC2H5cjs.boardCounterKey, String(Math.max(previous, next.board.number)));
+  await tx.setEntry(path, _chunkEYTVC2H5cjs.boardNumberKey.call(void 0, next.board.number), id);
+}
+
+
+
+exports.SeqKanbanStore = SeqKanbanStore;
+//# sourceMappingURL=chunk-VMRDXOLX.cjs.map

package/dist/chunk-VMRDXOLX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/li/share/prj/x1/libraries/kanban/dist/chunk-VMRDXOLX.cjs","../src/store.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACF,wDAA6B;AAC7B;AACA;ACtBA,2CAA0C;AAKnC,IAAM,eAAA,EAAN,MAAM,gBAAsC;AAAA,EAEvC,WAAA,CAA6B,EAAA,EAAkC,IAAA,EAAc,MAAA,EAA0B;AAA1E,IAAA,IAAA,CAAA,GAAA,EAAA,EAAA;AAAkC,IAAA,IAAA,CAAA,KAAA,EAAA,IAAA;AACnE,IAAA,IAAA,CAAK,OAAA,mBAAS,MAAA,UAAU,EAAC,IAAA,EAAM,MAAA,CAAM,IAAA,EAAA,GAAQ;AACzC,MAAA,MAAM,KAAA,EAAO,MAAM,EAAA,CAAG,IAAA,CAAK,MAAA,CAAO,QAAA,CAAS,IAAA,EAAM,CAAA,EAAA;AACC,MAAA;AACZ,MAAA;AACT,IAAA;AAA4C,MAAA;AAAiB,IAAA;AAClG,EAAA;AAPiB,EAAA;AAQ4F,EAAA;AAChE,IAAA;AACrC,IAAA;AAA2C,MAAA;AACjC,IAAA;AAAoD,MAAA;AAAuB,IAAA;AAC/C,IAAA;AAC9C,EAAA;AACsD,EAAA;AAA8C,IAAA;AAAwB,EAAA;AAC7F,EAAA;AACwB,IAAA;AACvD,EAAA;AACgG,EAAA;AACjD,IAAA;AACQ,IAAA;AAEzB,IAAA;AAE2B,IAAA;AACF,IAAA;AACvD,EAAA;AAEoF,EAAA;AAC9B,IAAA;AACjC,IAAA;AAAyE,IAAA;AACvC,IAAA;AAAqE,IAAA;AAC5H,EAAA;AACsG,EAAA;AAChD,IAAA;AACD,MAAA;AACD,MAAA;AAC/C,IAAA;AACL,EAAA;AACuB,EAAA;AAC+B,IAAA;AACnB,IAAA;AAAuB,IAAA;AACtB,IAAA;AAAyC,IAAA;AAC7E,EAAA;AACoD,EAAA;AAAgD,IAAA;AAAE,EAAA;AAExB,EAAA;AACtB,IAAA;AACJ,IAAA;AACnC,IAAA;AAAmC,MAAA;AAAuC,MAAA;AAA2B,MAAA;AAAQ,IAAA;AACzE,IAAA;AAC9B,IAAA;AAC2B,IAAA;AACG,IAAA;AACrD,EAAA;AACgG,EAAA;AAC1C,IAAA;AAEtC,IAAA;AAA8B,IAAA;AAES,IAAA;AACT,IAAA;AACO,MAAA;AAC1B,MAAA;AAAyC,QAAA;AAAU,QAAA;AAAK,MAAA;AACnC,MAAA;AACG,MAAA;AACE,MAAA;AACd,MAAA;AAAI,QAAA;AAAwC,QAAA;AAAM,QAAA;AAC3C,QAAA;AAA0C,QAAA;AAAc,MAAA;AACtC,MAAA;AACV,MAAA;AACvC,MAAA;AACV,IAAA;AACqB,IAAA;AACW,IAAA;AAAuD,IAAA;AAAU,IAAA;AACtG,EAAA;AACJ;AAC4J;AAChI,EAAA;AAC+B,IAAA;AACJ,IAAA;AACnD,EAAA;AACJ;AAEoI;AAC/E,EAAA;AACG,EAAA;AACC,EAAA;AACP,EAAA;AACI,EAAA;AACG,EAAA;AACH,EAAA;AACtD;AD2CwD;AACA;AACA;AACA","file":"/home/li/share/prj/x1/libraries/kanban/dist/chunk-VMRDXOLX.cjs","sourcesContent":[null,"import {numberEntities, boardCounterKey, boardNumberKey, counter, allocateBoardNumber, patchBoardNumber} from './numbering';\nimport type { KanbanEvent, KanbanArchivedItem } from './contracts';\nimport { FSError, type IFileSystem } from '@nestos/vfs-core';\nimport { KanbanError, type KanbanState, type KanbanStore } from './ports';\nimport {indexedView, viewFromState, archiveKey, boardKey as key, rowKeys, hydrate, encodeBoard, rowChanges, encodeRow, decodeRow, receiptDigest, verifyReceipt, type StoredBoard, type KanbanBodyStore} from './storage-codec';\n\n/** One user-scoped journal, with atomic board/index/receipt commits. */\nexport class SeqKanbanStore implements KanbanStore {\n    private readonly bodies: KanbanBodyStore;\n    private constructor(private readonly fs: IFileSystem, private readonly path: string, bodies?: KanbanBodyStore) {\n        this.bodies = bodies ?? {read: async hash => {\n            const body = await fs.meta.assets.getAsset(path, `${hash}.json`);\n            if (body === null || body instanceof ArrayBuffer) return body;\n            throw new KanbanError('BODY_INTEGRITY');\n        }, write: async (hash, bytes) => {await fs.meta.assets.putAsset(path, `${hash}.json`, bytes);}};\n    }\n    static async open(fs: IFileSystem, directory = '/kanban', bodies?: KanbanBodyStore): Promise<SeqKanbanStore> {\n        if (!fs.meta.seq?.transaction) throw new KanbanError('TRANSACTION_REQUIRED');\n        try { await fs.driver.createFile({ parentPath: directory, name: 'boards.seq', type: 'seqfile', recursive: true }); }\n        catch (error) { if (!(error instanceof FSError) || error.code !== 'EEXIST') throw error; }\n        return new SeqKanbanStore(fs, `${directory}/boards.seq`, bodies);\n    }\n    async boardId(number: number): Promise<string | null> {return this.fs.meta.seq!.getEntry(this.path, boardNumberKey(number));}\n    async ids(): Promise<string[]> {\n        return JSON.parse(await this.fs.meta.seq!.getEntry(this.path, 'index') ?? '[]');\n    }\n    async events(id: string, after: number, limit: number, through: number): Promise<KanbanEvent[]> {\n        const end = Math.min(through, after + limit);\n        const keys = Array.from({length: Math.max(0, end - after)}, (_, index) =>\n            `event/${encodeURIComponent(id)}/${String(after + index + 1).padStart(16, '0')}`);\n        if (!keys.length) return [];\n        // The committed sequence freezes this immutable prefix; bulk key reads avoid history scans.\n        const rows = await this.fs.meta.seq!.getEntries(this.path, keys);\n        return keys.filter(key => rows[key] !== undefined).map(key => JSON.parse(rows[key]) as KanbanEvent);\n    }\n\n    async archived(boardId: string, itemId: string): Promise<KanbanArchivedItem | null> {\n        const raw = await this.fs.meta.seq!.getEntry(this.path, archiveKey(boardId, itemId));\n        if (!raw) return null; const record = await decodeRow<KanbanArchivedItem>(raw, this.bodies);\n        record.item.number ??= (await this.view(boardId))?.state.archiveIndex?.find(item => item.id === itemId)?.number; return record;\n    }\n    private async load(id: string, receiptKey?: string): Promise<StoredBoard & {receipt?: string | null}> {\n        return this.fs.meta.seq!.transaction!(async tx => {\n            const raw = await tx.getEntry(this.path, key(id));\n            return {raw, rows: await tx.getEntries(this.path, rowKeys(raw)), receipt: receiptKey ? await tx.getEntry(this.path, receiptKey) : undefined};\n        });\n    }\n    async view(id: string) {\n        const raw = await this.fs.meta.seq!.getEntry(this.path, key(id));\n        const indexed = indexedView(raw); if (indexed) return indexed;\n        const state = await this.read(id); return state ? viewFromState(state) : null;\n    }\n    async read(id: string): Promise<KanbanState | null> {return hydrate(await this.load(id), this.bodies);}\n    async update(id: string, operationId: string, fingerprint: string,\n        change: (state: KanbanState | null) => KanbanState): Promise<KanbanState> {\n        const receiptKey = `receipt/${encodeURIComponent(id)}/${encodeURIComponent(operationId)}`;\n        const before = await this.load(id, receiptKey), current = await hydrate(before, this.bodies), receipt = before.receipt;\n        if (receipt) {verifyReceipt(receipt, fingerprint); if (!current) throw new KanbanError('CORRUPT_RECEIPT'); return current;}\n        const original = JSON.stringify(current), next = change(current);\n        numberEntities(next);\n        if (JSON.stringify(next) === original) return next;\n        return this.persist(id, receiptKey, fingerprint, before, next);\n    }\n    private async persist(id: string, receiptKey: string, fingerprint: string, before: StoredBoard, next: KanbanState): Promise<KanbanState> {\n        const events = [...next.events], archives = await Promise.all((next.archiveWrites ?? []).map(async write =>\n            ({key: archiveKey(id, write.id), value: write.value ? await encodeRow(write.value, this.bodies) : null})));\n        delete next.archiveWrites; next.events = [];\n        // No asset I/O runs under the SeqFile transaction: it may use the same backend.\n        const encoded = await encodeBoard(next, this.bodies);\n        const committed = await this.fs.meta.seq!.transaction!(async tx => {\n            const latestReceipt = await tx.getEntry(this.path, receiptKey);\n            if (latestReceipt) {verifyReceipt(latestReceipt, fingerprint); return null;}\n            if (await tx.getEntry(this.path, key(id)) !== before.raw) throw new KanbanError('REVISION_CONFLICT');\n            await commitBoardNumber(tx, this.path, id, before, next, encoded);\n            const eventRows = events.map(event => ({key: `event/${encodeURIComponent(id)}/${String(event.sequence).padStart(16, '0')}`, value: JSON.stringify(event)}));\n            await writeRows(tx, this.path, [...eventRows, ...rowChanges(before, encoded), ...archives,\n                {key: key(id), value: encoded.raw!}, {key: receiptKey, value: receiptDigest(fingerprint)}]);\n            const ids: string[] = JSON.parse(await tx.getEntry(this.path, 'index') ?? '[]');\n            if (!ids.includes(id)) await tx.setEntry(this.path, 'index', JSON.stringify([...ids, id]));\n            return next;\n        });\n        if (committed) return committed;\n        const replay = await this.read(id); if (!replay) throw new KanbanError('CORRUPT_RECEIPT'); return replay;\n    }\n}\nasync function writeRows(tx: import('@nestos/vfs-core').ISeqFileTransaction, path: string, rows: Array<{key: string; value: string | null}>): Promise<void> {\n    for (const row of rows) {\n        if (row.value === null) await tx.deleteEntry(path, row.key);\n        else await tx.setEntry(path, row.key, row.value);\n    }\n}\n\nasync function commitBoardNumber(tx: import('@nestos/vfs-core').ISeqFileTransaction, path: string, id: string, before: StoredBoard, next: KanbanState, encoded: StoredBoard): Promise<void> {\n    const previous = counter(await tx.getEntry(path, boardCounterKey));\n    next.board.number = allocateBoardNumber(before.raw, previous);\n    const owner = await tx.getEntry(path, boardNumberKey(next.board.number));\n    if (owner !== null && owner !== id) throw new KanbanError('INVALID_NUMBERING');\n    encoded.raw = patchBoardNumber(encoded.raw!, next.board.number);\n    await tx.setEntry(path, boardCounterKey, String(Math.max(previous, next.board.number)));\n    await tx.setEntry(path, boardNumberKey(next.board.number), id);\n}\n"]}

package/dist/chunk-X4UHZX6F.js

@@ -0,0 +1,58 @@
+// src/contracts/references.ts
+function kanbanReference(board, entity) {
+  const prefix = board.number ? `KB-${board.number}` : board.id;
+  if (!entity) return prefix;
+  if (!entity.number) return `${prefix}/${entity.id}`;
+  return entity.kind ? `${prefix}/${entity.kind === "log" ? "L" : "D"}-${entity.number}` : `${prefix}#${entity.number}`;
+}
+
+// src/contracts/configuration.ts
+var DEFAULT_KANBAN_WORK_TYPES = [
+  { id: "initiative", label: "Goal", rank: 0, executable: false },
+  { id: "feature", label: "Group", rank: 1, executable: false },
+  { id: "task", label: "Action", rank: 2, executable: true },
+  { id: "fix", label: "Fix", rank: 2, executable: true },
+  { id: "subtask", label: "Subtask", rank: 3, executable: true }
+];
+function executableWorkItem(board, item) {
+  return item.planning?.execution !== "children" && (board.workTypes ?? DEFAULT_KANBAN_WORK_TYPES).some((type) => type.id === (item.planning?.kind ?? board.defaultWorkType ?? "task") && type.executable);
+}
+
+// src/contracts/discovery.ts
+var DEFAULT_KANBAN_SCAN_POLICY = {
+  idleMs: 3e5,
+  includeArchived: true,
+  maxSessions: 20,
+  maxInputBytes: 128 * 1024,
+  leaseMs: 6e5,
+  autoCreate: false
+};
+
+// src/contracts/automation.ts
+function sameAutomationBinding(left, right) {
+  const signature = (value) => JSON.stringify([
+    value?.planner?.system,
+    value?.planner?.id,
+    value?.planner?.revision,
+    value?.executor?.system,
+    value?.executor?.id,
+    value?.executor?.revision,
+    value?.coordinator?.kind,
+    value?.coordinator?.id,
+    value?.worker?.kind,
+    value?.worker?.id,
+    value?.autoAccept,
+    value?.preparation,
+    Object.entries(value?.preparationOptions ?? {}).sort(([a], [b]) => a.localeCompare(b))
+  ]);
+  return signature(left) === signature(right);
+}
+
+export {
+  kanbanReference,
+  DEFAULT_KANBAN_WORK_TYPES,
+  executableWorkItem,
+  DEFAULT_KANBAN_SCAN_POLICY,
+  sameAutomationBinding
+};
+//# sourceMappingURL=chunk-X4UHZX6F.js.map

package/dist/chunk-X4UHZX6F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contracts/references.ts","../src/contracts/configuration.ts","../src/contracts/discovery.ts","../src/contracts/automation.ts"],"sourcesContent":["import type {KanbanBoard} from './contracts';\n\nexport interface KanbanReferenceTarget {boardId: string; itemId?: string; recordId?: string; reference: string; scope: KanbanBoard['scope']}\nexport function kanbanReference(board: {id: string; number?: number}, entity?: {id: string; number?: number; kind?: 'log' | 'decision'}): string {\n    const prefix = board.number ? `KB-${board.number}` : board.id;\n    if (!entity) return prefix;\n    if (!entity.number) return `${prefix}/${entity.id}`;\n    return entity.kind ? `${prefix}/${entity.kind === 'log' ? 'L' : 'D'}-${entity.number}` : `${prefix}#${entity.number}`;\n}\n","import type {KanbanItem, KanbanBoard} from './contracts';\n\nexport interface KanbanPrincipal {kind: 'agent' | 'human' | 'service'; id: string}\nexport interface KanbanMember extends KanbanPrincipal {\n    responsibility: string; roles?: Array<'worker' | 'reviewer' | 'coordinator'>;\n}\nexport interface KanbanWorkType {id: string; label: string; rank: number; executable: boolean}\nexport interface KanbanColumn {id: string; label: string; states: KanbanItem['status'][]}\nexport interface KanbanNotificationPolicy {rules?: Record<string, 'info' | 'error' | 'none'>}\nexport const DEFAULT_KANBAN_WORK_TYPES: readonly KanbanWorkType[] = [\n    {id: 'initiative', label: 'Goal', rank: 0, executable: false},\n    {id: 'feature', label: 'Group', rank: 1, executable: false},\n    {id: 'task', label: 'Action', rank: 2, executable: true},\n    {id: 'fix', label: 'Fix', rank: 2, executable: true},\n    {id: 'subtask', label: 'Subtask', rank: 3, executable: true},\n];\n\nexport interface KanbanExternalReference {system: string; id: string; revision?: string}\n\n/** A composite work item delegates execution to its children. */\nexport function executableWorkItem(board:Pick<KanbanBoard,'workTypes'|'defaultWorkType'>, item:{planning?:{kind:string;execution?:'direct'|'children'}}):boolean {\n    return item.planning?.execution!=='children'&&(board.workTypes??DEFAULT_KANBAN_WORK_TYPES)\n        .some(type=>type.id===(item.planning?.kind??board.defaultWorkType??'task')&&type.executable);\n}\n","import type {KanbanItemSummary} from './planning';\nimport type {KanbanBoard} from './contracts';\n\nexport type {KanbanSourceRef, KanbanDiscoveryChange, KanbanDiscoveryBatch} from './source';\nimport type {KanbanDiscoveryChange} from './source';\nexport interface KanbanScanSession {\n    id: string; revision: string; updatedAt: number | null; idleSince: number | null;\n    activity: 'idle' | 'active' | 'waiting' | 'unknown'; archived: boolean; scannerOwned?: boolean;\n}\nexport interface KanbanScanText {\n    session: KanbanScanSession; complete: boolean;\n    messages: Array<{id: string; role: 'user' | 'assistant'; text: string}>;\n}\nexport interface KanbanScanConnection {\n    kind: 'local' | 'remote'; connectionId: string;\n    /** Explicit consent for moving source text to a different execution boundary. */\n    allowContentTransfer: boolean;\n}\nexport interface KanbanScanPolicy {\n    idleMs: number; includeArchived: boolean; maxSessions: number; maxInputBytes: number; leaseMs: number;\n    autoCreate: boolean; connection: KanbanScanConnection;\n}\nexport interface KanbanScanInput {\n    projectContext?: {totalRecords: number; excludedRecords?: number; omittedRecords: number; records: import('./context').KanbanProjectRecord[]};\n    context?: {totalItems: number; omittedItems: number; archivedTotal: number; archivedItems: KanbanItemSummary[]};\n    runId: string; executorId: string; board: KanbanBoard; sessions: KanbanScanText[]; connection: KanbanScanConnection;\n}\nexport const DEFAULT_KANBAN_SCAN_POLICY: Omit<KanbanScanPolicy, 'connection'> = {\n    idleMs: 300000, includeArchived: true, maxSessions: 20, maxInputBytes: 128 * 1024, leaseMs: 600000, autoCreate: false,\n};\n\nexport interface KanbanDiscoveryResult {changes: KanbanDiscoveryChange[]; records?: import('./context').KanbanRecordInput[]}\n","import type {KanbanExternalReference, KanbanPrincipal} from './configuration';\n\nexport interface KanbanAutomationSettings {\n    preparation?: KanbanExternalReference;\n    preparationOptions?: Record<string, string>;\n    enabled: boolean; planner: KanbanExternalReference; executor: KanbanExternalReference;\n    coordinator: KanbanPrincipal; worker: KanbanPrincipal; autoAccept: boolean;\n}\nexport interface KanbanAutomationOption {\n    name: string; label: string; defaultValue?: string;\n    choices?: Array<{value: string; label: string}>;\n}\nexport interface KanbanAutomationTarget {reference: KanbanExternalReference; label: string; options?: KanbanAutomationOption[]}\nexport interface KanbanAutomationCatalog {\n    preparations?: KanbanAutomationTarget[];\n    targets: KanbanAutomationTarget[]; coordinator: KanbanPrincipal; worker: KanbanPrincipal;\n}\nexport interface KanbanAnalysisStatus {\n    itemId: string; state: 'analyzing' | 'ready' | 'clarification' | 'failed' | 'unknown';\n    reason?: string; code?: string; dependencies?: string[];\n}\nexport function sameAutomationBinding(left?: KanbanAutomationSettings, right?: KanbanAutomationSettings): boolean {\n    const signature = (value?: KanbanAutomationSettings) => JSON.stringify([value?.planner?.system, value?.planner?.id, value?.planner?.revision,\n        value?.executor?.system, value?.executor?.id, value?.executor?.revision, value?.coordinator?.kind, value?.coordinator?.id,\n        value?.worker?.kind, value?.worker?.id, value?.autoAccept, value?.preparation, Object.entries(value?.preparationOptions ?? {}).sort(([a], [b]) => a.localeCompare(b))]);\n    return signature(left) === signature(right);\n}\n"],"mappings":";AAGO,SAAS,gBAAgB,OAAsC,QAA2E;AAC7I,QAAM,SAAS,MAAM,SAAS,MAAM,MAAM,MAAM,KAAK,MAAM;AAC3D,MAAI,CAAC,OAAQ,QAAO;AACpB,MAAI,CAAC,OAAO,OAAQ,QAAO,GAAG,MAAM,IAAI,OAAO,EAAE;AACjD,SAAO,OAAO,OAAO,GAAG,MAAM,IAAI,OAAO,SAAS,QAAQ,MAAM,GAAG,IAAI,OAAO,MAAM,KAAK,GAAG,MAAM,IAAI,OAAO,MAAM;AACvH;;;ACCO,IAAM,4BAAuD;AAAA,EAChE,EAAC,IAAI,cAAc,OAAO,QAAQ,MAAM,GAAG,YAAY,MAAK;AAAA,EAC5D,EAAC,IAAI,WAAW,OAAO,SAAS,MAAM,GAAG,YAAY,MAAK;AAAA,EAC1D,EAAC,IAAI,QAAQ,OAAO,UAAU,MAAM,GAAG,YAAY,KAAI;AAAA,EACvD,EAAC,IAAI,OAAO,OAAO,OAAO,MAAM,GAAG,YAAY,KAAI;AAAA,EACnD,EAAC,IAAI,WAAW,OAAO,WAAW,MAAM,GAAG,YAAY,KAAI;AAC/D;AAKO,SAAS,mBAAmB,OAAuD,MAAuE;AAC7J,SAAO,KAAK,UAAU,cAAY,eAAa,MAAM,aAAW,2BAC3D,KAAK,UAAM,KAAK,QAAM,KAAK,UAAU,QAAM,MAAM,mBAAiB,WAAS,KAAK,UAAU;AACnG;;;ACIO,IAAM,6BAAmE;AAAA,EAC5E,QAAQ;AAAA,EAAQ,iBAAiB;AAAA,EAAM,aAAa;AAAA,EAAI,eAAe,MAAM;AAAA,EAAM,SAAS;AAAA,EAAQ,YAAY;AACpH;;;ACRO,SAAS,sBAAsB,MAAiC,OAA2C;AAC9G,QAAM,YAAY,CAAC,UAAqC,KAAK,UAAU;AAAA,IAAC,OAAO,SAAS;AAAA,IAAQ,OAAO,SAAS;AAAA,IAAI,OAAO,SAAS;AAAA,IAChI,OAAO,UAAU;AAAA,IAAQ,OAAO,UAAU;AAAA,IAAI,OAAO,UAAU;AAAA,IAAU,OAAO,aAAa;AAAA,IAAM,OAAO,aAAa;AAAA,IACvH,OAAO,QAAQ;AAAA,IAAM,OAAO,QAAQ;AAAA,IAAI,OAAO;AAAA,IAAY,OAAO;AAAA,IAAa,OAAO,QAAQ,OAAO,sBAAsB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAAA,EAAC,CAAC;AAC1K,SAAO,UAAU,IAAI,MAAM,UAAU,KAAK;AAC9C;","names":[]}

package/dist/chunk-XBSGUVCY.cjs

@@ -0,0 +1,382 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk4XF6LQSUcjs = require('./chunk-4XF6LQSU.cjs');
+
+
+
+
+var _chunkRSH6QSECcjs = require('./chunk-RSH6QSEC.cjs');
+
+
+
+var _chunkAOHQCX7Kcjs = require('./chunk-AOHQCX7K.cjs');
+
+// src/execution-bridge.ts
+async function createKanbanExecutionBridge(options) {
+  const path = `${options.directory}/executions.seq`;
+  try {
+    await options.fs.driver.createFile({ parentPath: options.directory, name: "executions.seq", type: "seqfile", recursive: true });
+  } catch (error) {
+    if (_optionalChain([error, 'optionalAccess', _ => _.code]) !== "EEXIST") throw error;
+  }
+  if (!_optionalChain([options, 'access', _2 => _2.fs, 'access', _3 => _3.meta, 'access', _4 => _4.seq, 'optionalAccess', _5 => _5.transaction])) throw new (0, _chunkRSH6QSECcjs.KanbanError)("TRANSACTION_REQUIRED");
+  let stopped = false, again = false, pending;
+  const writes = /* @__PURE__ */ new Set();
+  const failures = /* @__PURE__ */ new Map();
+  const track = (operation) => {
+    const tracked = operation.finally(() => {
+      writes.delete(tracked);
+    });
+    writes.add(tracked);
+    return tracked;
+  };
+  const active = () => !stopped;
+  const scan = async () => {
+    if (stopped) return;
+    if (pending) {
+      again = true;
+      return pending;
+    }
+    const started = Date.now();
+    pending = runBridge(options, path, active, track, failures).catch((error) => {
+      try {
+        options.log({ operationId: _chunkRSH6QSECcjs.randomUUID.call(void 0, ), stage: "bridge.scan", result: "failure", code: safeCode(error), durationMs: Date.now() - started });
+      } catch (e) {
+      }
+      throw error;
+    }).finally(() => {
+      pending = void 0;
+      if (again && !stopped) {
+        again = false;
+        void scan().catch(() => {
+        });
+      }
+    });
+    return pending;
+  };
+  const unsubscribe = _optionalChain([options, 'access', _6 => _6.subscribe, 'optionalCall', _7 => _7(() => {
+    void scan().catch(() => {
+    });
+  })]);
+  return { scan, tick: scan, async quiesce() {
+    stopped = true;
+    _optionalChain([unsubscribe, 'optionalCall', _8 => _8()]);
+    if (!pending) return;
+    let timer;
+    try {
+      await Promise.race([pending, new Promise((resolve) => {
+        timer = setTimeout(resolve, _nullishCoalesce(options.shutdownTimeoutMs, () => ( 5e3)));
+      })]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      await Promise.allSettled([...writes]);
+    }
+  } };
+}
+async function runBridge(options, path, active, track, failures) {
+  const workflow = await options.service.workflow(options.boardId);
+  const live = new Set(Object.values(workflow.dispatches).filter((dispatch) => ["prepared", "running", "unknown"].includes(dispatch.outcome)).map((dispatch) => dispatch.id));
+  for (const id of failures.keys()) if (!live.has(id)) failures.delete(id);
+  for (const dispatch of Object.values(workflow.dispatches)) {
+    if (!active()) return;
+    if (live.has(dispatch.id) && (_nullishCoalesce(_optionalChain([failures, 'access', _9 => _9.get, 'call', _10 => _10(dispatch.id), 'optionalAccess', _11 => _11.retryAt]), () => ( 0))) <= Date.now()) await runDispatch(options, path, dispatch, active, track, failures);
+  }
+  const automatic = typeof options.autoDispatch === "function" ? await options.autoDispatch() : options.autoDispatch;
+  if (!automatic || !active()) return;
+  for (const id of (await options.service.workflow(options.boardId)).ready) {
+    if (!active()) return;
+    const { item } = await options.service.item(options.boardId, id), owner = _optionalChain([item, 'access', _12 => _12.eligiblePrincipals, 'optionalAccess', _13 => _13[0]]);
+    if (!owner || !_chunkAOHQCX7Kcjs.taskDue.call(void 0, item, (_nullishCoalesce(options.now, () => ( Date.now)))())) continue;
+    const worker = await options.worker(owner), board = await worker.read(options.boardId);
+    if (!active()) return;
+    if (!_chunkAOHQCX7Kcjs.boardAllowsStart.call(void 0, board, item)) continue;
+    try {
+      const dispatchId = _chunkRSH6QSECcjs.randomUUID.call(void 0, );
+      const estimate = await _optionalChain([options, 'access', _14 => _14.estimate, 'optionalCall', _15 => _15(item, owner)]);
+      if (!active()) return;
+      await worker.execute(board.id, { operationId: "dispatch:" + dispatchId, expectedRevision: board.revision, command: { type: "prepare-dispatch", itemId: id, dispatchId, estimate, trigger: "automatic" } });
+      const dispatch = (await options.service.workflow(board.id)).dispatches[dispatchId];
+      if (active()) await runDispatch(options, path, dispatch, active, track, failures);
+    } catch (error) {
+      if (!["WIP_LIMIT", "ASSIGNEE_WIP_LIMIT", "READY_LIMIT", "REVISION_CONFLICT"].includes(safeCode(error))) throw error;
+    }
+  }
+}
+async function runDispatch(options, path, dispatch, active, track, failures) {
+  const start = Date.now();
+  let stage = "inspect", result;
+  const previousFailure = failures.has(dispatch.id);
+  try {
+    let record = await loadRecord(options, path, dispatch);
+    if (!active()) return;
+    const current = await options.service.item(options.boardId, dispatch.itemId);
+    if ((_optionalChain([current, 'access', _16 => _16.item, 'access', _17 => _17.control, 'optionalAccess', _18 => _18.action]) === "cancel" || (await options.service.read(options.boardId)).lifecycle) && await track(preventSubmission(options, path, dispatch))) {
+      await settle(options, dispatch, { outcome: "cancelled", code: "CANCELLED_BEFORE_START" });
+      return;
+    }
+    if ((!record || record.phase === "prepared") && (await _asyncOptionalChain([(await options.service.read(options.boardId)), 'access', async _19 => _19.executionControl, 'optionalAccess', async _20 => _20.paused]) || _optionalChain([current, 'access', _21 => _21.item, 'access', _22 => _22.control, 'optionalAccess', _23 => _23.action]) === "pause")) return;
+    if (!record) {
+      stage = "prepare";
+      await options.authorize(stage, dispatch);
+      if (!active()) return;
+      const item = (await options.service.item(options.boardId, dispatch.itemId)).item;
+      if (!active()) return;
+      const request = await prepareRequest(options, path, dispatch, item);
+      if (!active()) return;
+      record = await track(savePrepared(options, path, dispatch, request));
+    }
+    if (!active()) return;
+    const submit = record.phase === "prepared" && await track(claimSubmission(options, path, dispatch));
+    if (!submit && await options.fs.meta.seq.getEntry(path, "cancelled:" + dispatch.id)) {
+      await settle(options, dispatch, { outcome: "cancelled", code: "CANCELLED_BEFORE_START" });
+      return;
+    }
+    if (!active()) return;
+    stage = submit ? "start" : "inspect";
+    await options.authorize(stage, dispatch);
+    if (!active()) return;
+    result = await (submit ? options.executor.start(record.request) : options.executor.inspect(record.request));
+    failures.delete(dispatch.id);
+  } catch (error) {
+    const notStarted = _optionalChain([error, 'optionalAccess', _24 => _24.executionOutcome]) === "not-started" && error.retryable === true;
+    if (notStarted && stage === "start") await track(releaseUnstartedSubmission(options, path, dispatch));
+    result = { outcome: stage === "prepare" && !notStarted ? "failed" : "unknown", code: safeCode(error) };
+    if (stage === "inspect" || notStarted) {
+      const previous = failures.get(dispatch.id), count = previous && previous.code === result.code ? previous.count + 1 : 1;
+      failures.set(dispatch.id, { code: result.code, count, retryAt: Date.now() + Math.min(6e4, 1e3 * 2 ** Math.min(count - 1, 6)) });
+    }
+  }
+  if (stage !== "inspect" || _chunk4XF6LQSUcjs.executionObservationChanged.call(void 0, dispatch, result) || previousFailure && !failures.has(dispatch.id))
+    try {
+      options.log({ operationId: dispatch.id, stage: `bridge.${stage}`, result: ["unknown", "failed", "cancelled"].includes(result.outcome) ? "failure" : "success", code: result.code, ...failures.has(dispatch.id) ? { retryAfterMs: Math.max(0, failures.get(dispatch.id).retryAt - Date.now()) } : {}, durationMs: Date.now() - start });
+    } catch (e2) {
+    }
+  if (active()) try {
+    await linkSession(options, dispatch, result.executionSessionId);
+    if (active()) await settle(options, dispatch, result);
+  } catch (error) {
+    if (safeCode(error) !== "REVISION_CONFLICT") throw error;
+  }
+}
+async function releaseUnstartedSubmission(options, path, dispatch) {
+  await options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (!raw) throw new (0, _chunkRSH6QSECcjs.KanbanError)("EXECUTION_JOURNAL_MISSING");
+    const record = decodeRecord(raw, dispatch);
+    if (record.phase === "submitting") await tx.setEntry(path, dispatch.id, JSON.stringify({ ...record, phase: "prepared" }));
+  });
+}
+async function prepareRequest(options, path, dispatch, item) {
+  if (!dispatch.continuation) return options.executor.prepare(dispatch, item);
+  if (!options.executor.prepareContinuation) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CONTINUATION_UNSUPPORTED");
+  const previous = (await options.service.workflow(options.boardId)).dispatches[dispatch.continuation.previousDispatchId];
+  if (!previous || previous.itemId !== dispatch.itemId) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CONTINUATION_SCOPE_MISMATCH");
+  const record = await loadRecord(options, path, previous);
+  if (!record) throw new (0, _chunkRSH6QSECcjs.KanbanError)("EXECUTION_JOURNAL_MISSING");
+  return options.executor.prepareContinuation(dispatch, item, record.request);
+}
+async function loadRecord(options, path, dispatch) {
+  const raw = await options.fs.meta.seq.getEntry(path, dispatch.id);
+  if (!raw) return;
+  return decodeRecord(raw, dispatch);
+}
+async function savePrepared(options, path, dispatch, request) {
+  const rawRequest = JSON.stringify(request);
+  if (typeof rawRequest !== "string" || new TextEncoder().encode(rawRequest).byteLength > 1024 * 1024) throw new (0, _chunkRSH6QSECcjs.KanbanError)("INVALID_EXECUTION_REQUEST");
+  return options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (raw) return decodeRecord(raw, dispatch);
+    const record = { schema: 1, fence: dispatch.fence, request: JSON.parse(rawRequest), digest: _chunkRSH6QSECcjs.sha256HexSync.call(void 0, rawRequest), phase: "prepared" };
+    await tx.setEntry(path, dispatch.id, JSON.stringify(record));
+    return record;
+  });
+}
+async function claimSubmission(options, path, dispatch) {
+  return options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (!raw) throw new (0, _chunkRSH6QSECcjs.KanbanError)("EXECUTION_JOURNAL_MISSING");
+    const record = decodeRecord(raw, dispatch);
+    if (record.phase !== "prepared" || await tx.getEntry(path, "cancelled:" + dispatch.id)) return false;
+    await tx.setEntry(path, dispatch.id, JSON.stringify({ ...record, phase: "submitting" }));
+    return true;
+  });
+}
+function decodeRecord(raw, dispatch) {
+  const record = JSON.parse(raw);
+  if (record.schema !== 1 || record.fence !== dispatch.fence || !["prepared", "submitting"].includes(record.phase) || record.digest !== _chunkRSH6QSECcjs.sha256HexSync.call(void 0, JSON.stringify(record.request))) throw new (0, _chunkRSH6QSECcjs.KanbanError)("INVALID_EXECUTION_JOURNAL");
+  return record;
+}
+async function settle(options, dispatch, result) {
+  const current = (await options.service.workflow(options.boardId)).dispatches[dispatch.id];
+  if (!current || !["prepared", "running", "unknown"].includes(current.outcome)) return;
+  const board = await options.service.read(options.boardId), item = board.items.find((item2) => item2.id === dispatch.itemId);
+  const renew = ["running", "unknown"].includes(result.outcome) && (_nullishCoalesce(_optionalChain([item, 'optionalAccess', _25 => _25.owner, 'optionalAccess', _26 => _26.leaseUntil]), () => ( 0))) <= Date.now() + board.policy.leaseMs / 2;
+  if (!renew && !_chunk4XF6LQSUcjs.executionObservationChanged.call(void 0, current, result)) return;
+  const { outcome, outputs, code, executionSessionId, controlCapabilities } = result, observation = { outcome, ...controlCapabilities ? { controlCapabilities } : {}, ...executionSessionId ? { executionSessionId } : {}, ...outputs ? { outputs } : {}, ...code ? { code } : {} };
+  const digest = _chunkRSH6QSECcjs.sha256HexSync.call(void 0, JSON.stringify(observation));
+  await options.service.execute(board.id, {
+    operationId: `settle:${dispatch.id}:${digest}:${board.revision}`,
+    expectedRevision: board.revision,
+    command: { type: "observe-execution", dispatchId: dispatch.id, fence: dispatch.fence, ...observation }
+  });
+}
+async function linkSession(options, dispatch, sessionId) {
+  if (!sessionId || !options.executionReference) return;
+  const reference = options.executionReference(sessionId, dispatch.id);
+  const board = await options.service.read(options.boardId), item = board.items.find((item2) => item2.id === dispatch.itemId);
+  if (_optionalChain([item, 'optionalAccess', _27 => _27.owner, 'optionalAccess', _28 => _28.token]) !== dispatch.fence) throw new (0, _chunkRSH6QSECcjs.KanbanError)("STALE_EXECUTION_RESULT");
+  const current = _optionalChain([item, 'access', _29 => _29.externalRefs, 'optionalAccess', _30 => _30.filter, 'call', _31 => _31((ref) => ref.system === reference.system), 'access', _32 => _32.at, 'call', _33 => _33(-1)]);
+  if (_optionalChain([current, 'optionalAccess', _34 => _34.id]) === reference.id && current.revision === reference.revision) return;
+  await options.service.execute(board.id, {
+    operationId: `execution-session:${dispatch.id}:${_chunkRSH6QSECcjs.sha256HexSync.call(void 0, sessionId)}:${board.revision}`,
+    expectedRevision: board.revision,
+    command: { type: "link-reference", itemId: dispatch.itemId, reference }
+  });
+}
+function safeCode(error) {
+  const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _35 => _35.reasonCode]), () => ( _optionalChain([error, 'optionalAccess', _36 => _36.code])));
+  return typeof code === "string" && /^[A-Z][A-Z0-9_]{0,79}$/.test(code) ? code : "EXECUTION_OBSERVATION_FAILED";
+}
+async function preventSubmission(options, path, dispatch) {
+  return options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (raw && decodeRecord(raw, dispatch).phase === "submitting") return false;
+    await tx.setEntry(path, "cancelled:" + dispatch.id, dispatch.fence);
+    return true;
+  });
+}
+
+// src/monitor.ts
+function startKanbanMonitor(options) {
+  let stopped = false, pending;
+  const tick = () => {
+    if (stopped || pending) return;
+    pending = Promise.resolve().then(() => stopped ? void 0 : options.service.scan()).then(() => stopped ? void 0 : _optionalChain([options, 'access', _37 => _37.onSuccess, 'optionalCall', _38 => _38()])).catch(async (error) => {
+      if (stopped) return;
+      try {
+        await options.onError(error);
+      } catch (e3) {
+      }
+    }).finally(() => {
+      pending = void 0;
+    });
+  };
+  const unsubscribe = options.subscribeTick(tick), unwatch = _optionalChain([options, 'access', _39 => _39.subscribeChanges, 'optionalCall', _40 => _40(tick)]);
+  if (options.initialScan !== false) tick();
+  return { async dispose() {
+    if (stopped) {
+      await pending;
+      return;
+    }
+    stopped = true;
+    try {
+      unsubscribe();
+      _optionalChain([unwatch, 'optionalCall', _41 => _41()]);
+    } finally {
+      await pending;
+    }
+  } };
+}
+
+// src/work-messages.ts
+var _vfscore = require('@nestos/vfs-core');
+async function consumeWorkMessages(fs, directory, scope, journal, deliver, decode, publishReply) {
+  const publications = await readPublications(fs, directory, scope, decode), indexKey = "workspace-message-index:" + scope.attemptId;
+  const known = await _asyncNullishCoalesce(await journal.get(indexKey), async () => ( []));
+  if (known.some((id) => !publications.some((p) => p.message.id === id))) throw protocolError("WORK_MESSAGE_MISSING", "Published workspace message is missing", "ECONFLICT");
+  unresolvedWorkIssues(publications.map((p) => p.message));
+  publications.sort((a, b) => Number(a.message.type === "resolved") - Number(b.message.type === "resolved"));
+  for (const { message, bytes } of publications) {
+    const digest = _chunkRSH6QSECcjs.sha256HexSync.call(void 0, bytes);
+    const delivered = await deliverPublication(journal, indexKey, message, digest, deliver);
+    if (delivered) await publishReply(directory + "/outbox", "ack-" + message.id + ".yaml", JSON.stringify({ schema: "work-reply/1", ...scope, id: "ack-" + message.id, type: "accepted", replyTo: message.id, content: "Accepted", digest }));
+  }
+  return publications.map((p) => p.message);
+}
+async function readPublications(fs, directory, scope, decode) {
+  const files = await fs.driver.getChildren(directory + "/inbox", { fields: "entry" }), publications = [];
+  if (files.length > 200) throw protocolError("WORK_MESSAGE_COUNT_LIMIT", "Workspace inbox exceeds 200 entries");
+  for (const file of files.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (file.type !== "file" || !/^[a-zA-Z0-9_-]{1,128}\.(yaml|yml|json)$/.test(file.name)) continue;
+    const bytes = await readMessageBytes(fs, directory + "/inbox/" + file.name);
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes), envelope = decode(text);
+    if (_optionalChain([envelope, 'optionalAccess', _42 => _42.schema]) === "work-message/2" && Object.hasOwn(envelope, "scopeId")) continue;
+    const message = parseWorkMessage(text, scope, decode);
+    if (file.name.slice(0, file.name.lastIndexOf(".")) !== message.id) throw protocolError("WORK_MESSAGE_FILENAME_MISMATCH", "Workspace message filename does not match its identity");
+    publications.push({ message, bytes });
+  }
+  return publications;
+}
+async function deliverPublication(journal, indexKey, message, digest, deliver) {
+  const key = "workspace-message:" + message.attemptId + ":" + message.id;
+  const receipt = await journal.update(key, (old) => {
+    if (old && old.digest !== digest) throw protocolError("WORK_MESSAGE_CHANGED", "Published workspace message changed", "ECONFLICT");
+    return _nullishCoalesce(old, () => ( { digest, message, delivered: false }));
+  });
+  await journal.update(indexKey, (old) => _optionalChain([old, 'optionalAccess', _43 => _43.includes, 'call', _44 => _44(message.id)]) ? old : [..._nullishCoalesce(old, () => ( [])), message.id]);
+  if (receipt.delivered) return true;
+  const outcome = await deliver(receipt.message);
+  if (_optionalChain([outcome, 'optionalAccess', _45 => _45.pending])) return false;
+  await journal.update(key, (old) => ({ ...old, delivered: true }));
+  return true;
+}
+function parseWorkMessage(text, scope, decode) {
+  let value;
+  try {
+    value = decode(text);
+  } catch (e4) {
+    throw protocolError("WORK_MESSAGE_YAML_INVALID", "Workspace message is not valid bounded YAML");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw protocolError("WORK_MESSAGE_SCHEMA_INVALID", "Workspace message schema is invalid");
+  if ("body" in value) {
+    if (Object.hasOwn(value, "content")) throw protocolError("WORK_MESSAGE_FIELDS_INVALID", "Workspace message must not contain both body and content");
+    value = { ...value, content: value.body };
+  }
+  if (Object.keys(value).some((key) => !["schema", "runId", "itemId", "attemptId", "id", "type", "content", "body", "replyTo"].includes(key)))
+    throw protocolError("WORK_MESSAGE_FIELDS_INVALID", "Workspace message contains undeclared fields");
+  validateEnvelope(value, scope);
+  return value;
+}
+function validateEnvelope(value, scope) {
+  if (!["work-message/1", "work-message/2"].includes(value.schema)) throw protocolError("WORK_MESSAGE_SCHEMA_INVALID", "Workspace message schema is unsupported");
+  if (!["progress", "clarification", "error", "result", ...value.schema === "work-message/2" ? ["resolved"] : []].includes(value.type))
+    throw protocolError("WORK_MESSAGE_TYPE_INVALID", "Workspace message schema does not permit this type");
+  if (!validId(value.id)) throw protocolError("WORK_MESSAGE_ID_INVALID", "Workspace message identity is invalid");
+  if (["runId", "itemId", "attemptId"].some((key) => value[key] !== scope[key]))
+    throw protocolError("WORK_MESSAGE_SCOPE_MISMATCH", "Workspace message execution scope is invalid");
+  if (typeof value.content !== "string" || !value.content.trim() || value.content.length > 8e3) throw protocolError("WORK_MESSAGE_CONTENT_INVALID", "Workspace message content is invalid");
+  if (value.replyTo !== void 0 && !validId(value.replyTo) || value.type === "resolved" && !value.replyTo)
+    throw protocolError("WORK_MESSAGE_REPLY_INVALID", "Workspace message reply target is invalid");
+}
+function validId(value) {
+  return typeof value === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(value);
+}
+function protocolError(reasonCode, message, code = "EINVAL") {
+  return Object.assign(new (0, _vfscore.FSError)(code, message), { reasonCode });
+}
+async function readMessageBytes(fs, path) {
+  const before = await fs.driver.getNode(path);
+  if (_optionalChain([before, 'optionalAccess', _46 => _46.type]) !== "file" || !Number.isSafeInteger(before.size) || before.size < 1) throw protocolError("WORK_MESSAGE_FILE_INVALID", "Workspace message is not a nonempty regular file");
+  if (before.size > 65536) throw protocolError("WORK_MESSAGE_SIZE_LIMIT", "Workspace message exceeds 64 KiB");
+  const bytes = await fs.driver.readContent(path, { encoding: "binary", length: before.size });
+  const after = await fs.driver.getNode(path);
+  if (bytes.byteLength !== before.size || _optionalChain([after, 'optionalAccess', _47 => _47.type]) !== "file" || after.size !== before.size || after.revision !== before.revision || after.modifiedAt !== before.modifiedAt)
+    throw protocolError("WORK_MESSAGE_READ_CONFLICT", "Workspace message changed while reading", "ECONFLICT");
+  return bytes;
+}
+function unresolvedWorkIssues(messages) {
+  const issues = messages.filter((m) => m.type === "clarification" || m.type === "error");
+  for (const resolution of messages.filter((m) => m.type === "resolved")) {
+    if (!issues.some((issue) => issue.id === resolution.replyTo)) throw Object.assign(new Error("Resolution target is not an issue in this attempt"), { code: "WORKSPACE_RESOLUTION_INVALID" });
+  }
+  return issues.filter((issue) => !messages.some((m) => m.type === "resolved" && m.replyTo === issue.id));
+}
+
+
+
+
+
+
+
+exports.createKanbanExecutionBridge = createKanbanExecutionBridge; exports.startKanbanMonitor = startKanbanMonitor; exports.consumeWorkMessages = consumeWorkMessages; exports.parseWorkMessage = parseWorkMessage; exports.unresolvedWorkIssues = unresolvedWorkIssues;
+//# sourceMappingURL=chunk-XBSGUVCY.cjs.map