@nestos/kanban 0.5.1 → 0.5.2

package/README.md

@@ -1,6 +1,20 @@
 # @nestos/kanban
 
-基于 VFS 的通用看板与工作协调库，仅依赖 `@nestos/vfs-core`。提供唯一责任人、估算与在制额度、依赖、验收、归档、日志和决策，以及持久派发意图。库不调用模型、不创建 Session/Task、不安装后台调度器。包含可独立挂载的 DOM UI；执行、来源与资源活动通过可选端口接入。
+## 独立安装与开发
+
+```sh
+npm install @nestos/kanban @nestos/vfs-core
+# 在本仓库开发
+pnpm install --frozen-lockfile
+pnpm typecheck
+pnpm test
+pnpm build
+pnpm pack
+```
+
+本包提供领域服务与运行时，不包含 DOM 界面、CSS 或 UI 依赖。`/contracts` 为前台与远程调用提供无 I/O 的契约和纯函数。
+
+基于 VFS 的通用看板与工作协调库，存储与运行时通过可选 peer `@nestos/vfs-core` 接入 VFS；使用这些入口时显式安装该依赖。提供唯一责任人、估算与在制额度、依赖、验收、归档、日志和决策，以及持久派发意图。库不调用模型、不创建 Session/Task、不安装后台调度器。执行、来源与资源活动通过可选端口接入。
 
 ```ts
 import {SeqKanbanStore, createKanbanModule} from '@nestos/kanban';
@@ -26,39 +40,17 @@ const service = createKanbanModule({
 | `/storage` | `SeqKanbanStore`、`ConditionalKanbanStore`、内容安装与传输端口 |
 | `/execution` | `createKanbanExecutionBridge`；宿主提供 prepare/start/inspect |
 | `/discovery` | `createKanbanDiscovery`；宿主提供来源、分析和授权 |
+| `/runtime` | `createKanbanRuntime`；单一工厂、执行意图/句柄/回执及完整协调 |
+| `/integration` | 自定义宿主的装配、业务协调与语义状态接口 |
 | `/activity` | `createKanbanActivityModule`；注入来源和外部引用 namespace |
-| `/ui`、`/ui.css` | DOM 工作区、`mountKanban` 与独立样式 |
 
 `createKanban(options)` 提供 `boards.create/get/list/overview`、`items.get/query`、`records.get/query`、`planning.get`、`references.resolve/suggest`、`execute`、`events`、`tick` 和 `quiesce/dispose`。execute 返回 `{boardId, operationId, revision}`；幂等重放时 revision 是当前返回快照的版本。需要 KanbanService（例如 UI、执行桥）时直接使用 `createKanbanModule`，二者共享同一实现与命令协议。
 
 主体 ID、Session/Task/Message ID 及历史持久格式保留。独立 Agent 可以只提供自己的 ID；若提供执行身份，所有权继续按该身份隔离。NestOS 在适配边界继续要求真实 Session/Task，宿主始终负责实际权限核验。
 
-## 独立 UI
-
-```ts
-import {mountKanban} from '@nestos/kanban/ui';
-import '@nestos/kanban/ui.css';
-
-const view = await mountKanban(container, {
-    service,
-    presentation: {
-        text: (key, values) => translations(key, values),
-        icons: {refreshView, more, close},
-        log: logMetadata,
-        referenceUrl: path => resourceUrl(path),
-    },
-    selected: path => saveNavigation(path),
-    openSession: id => openResource(id),
-});
-await view.open({boardId: 'work'});
-await view.dispose();
-```
-
-文案 key 不带 `kanban.` 前缀；图标为可信宿主提供的 SVG/HTML。主题通过 `--kanban-*` CSS 变量设置；NestOS 在适配样式中映射原有主题变量。所有呈现配置按实例注入，不存在全局语言、当前宿主或跨实例回调。UI 不导入 NestOS、common 或 vfs-ui。资源活动为可选能力；未接入时不显示执行筛选，也不安装活动轮询。接入时可见且没有未保存输入才轮询，销毁后停止；通知不会覆盖草稿。错误只展示安全错误码与宿主文案，不输出正文或完整请求。
+## 前台界面
 
-来源发现仅通过内置 `apply-discovery` 提交受校验的变更与检查点，二者同事务保存。宿主不提供可变 reducer 扩展。来源可声明 system/project/collection scope；历史 projectId 仍兼容。库不提供内部 mechanisms 入口。消费者直接从 `/contracts` 导入 DTO 和 KanbanClient，不经过应用包转出。
-
-执行桥不解释模型或业务。执行桥和来源扫描的 `tick()`（兼容 `scan()`）由宿主显式驱动；扫描 `quiesce/dispose` 拒绝新准入并排空已接纳操作。只有注入 subscribe 才接收唤醒。executionReference 将实际执行 ID 映射为宿主命名空间，不在核心写死 NestOS 引用。`ConditionalKanbanStore` 只要求 query/transaction 与可选正文资产端口，适配器负责授权连接及 unknown 写入核对，不在 Store 内盲重试。
+界面由独立包 `@nestos/kanban-ui` 提供，样式入口为 `@nestos/kanban-ui/style.css`。前台仅通过本库 `/contracts` 中的 KanbanClient 接入本地或远程服务，不依赖后台存储、执行或恢复实现。
 
 ## 版本化内容安装
 
@@ -109,7 +101,7 @@ VFS `seq:committed` 可用于唤醒宿主，但持久状态与定期补扫才是
 
 关闭顺序：停止事件/定时准入 → service.quiesce（拒新操作、等待已准入事务）→ 排空执行适配器 → 最后关闭 VFS。宿主重启后扫描持久派发、检查原执行身份并补投 outbox。SeqFile 不能与模型调用、远程服务或另一数据库组成单一事务，执行桥必须保留提交前日志和 unknown 状态。
 
-NestOS 的默认目录、远程 HttpSeqClient、Session 来源读取、发布 Agent/Flow、Kernel 回执、系统 notify 与调度接线均位于 `backend/app-core/src/kanban/`。扫描状态机、批量提交、远程事务编码与执行恢复归独立库；UI 的 NestOS 包装位于 `ui/app-shell/src/kanban/`。应用入口只导出实际 NestOS 绑定，不代转出库 API，核心没有这些运行依赖。完整规范见 [Kanban 协调设计](../../doc/design/kanban-coordination.md)。
+NestOS 的默认目录、远程 HttpSeqClient、Session 来源读取、发布 Agent/Flow、Kernel 回执、系统 notify 与调度接线均位于 `backend/app-core/src/kanban/`。扫描状态机、批量提交、远程事务编码与执行恢复归独立库；UI 的 NestOS 包装位于 `ui/app-shell/src/kanban/`。应用入口只导出实际 NestOS 绑定，不代转出库 API，核心没有这些运行依赖。完整规范见 [Kanban 协调设计](https://github.com/nest-agentos/NestOS/blob/main/doc/design/kanban-coordination.md)。
 
 会话活动入口 `executionSession(boardId, itemId)` 只读取当前执行摘要。显式传入 `{includeRelated: true}` 时，通过可选 `KanbanSessionSource.related` 合并宿主关联与已有执行绑定、参与者；返回的 `sessions` 按不透明 Session ID 去重，各自包含用途和 `executions` 执行记录。续办在同一 Session 下保留不同尝试，`current` 仅由正式执行绑定决定。UI 在展开「相关会话」时加载，支持刷新和宿主注入的原始资源链接；普通活动轮询不读取历史。资源属性由宿主提供，库不识别工作区、Git 或原生会话协议。
 
@@ -119,4 +111,56 @@ Boards may store automation settings with opaque planner/executor references and
 
 宿主已有工作区导航时，可直接构造 `KanbanWorkbench` 并省略 `sidebar`，通过 `createBoard()` 接入导航动作，通过 `committed` 刷新目录；`mountKanban` 的独立默认侧栏保持可用。父项详情提供子事项分页与新建入口，子项通过 `planning.parentId` 关联父项，执行依赖仍单独保存在 `planning.dependencies`。
 
-Task 的持久 startAt、编辑租约、单一状态投影与文件协议见 [执行规范](../../doc/design/kanban-task-execution.md)。`item().task` 和 query 的 `task` 为相同宿主事实的投影，`phase` 过滤在服务端执行。
+Task 的持久 startAt、编辑租约、单一状态投影与文件协议见 [执行规范](https://github.com/nest-agentos/NestOS/blob/main/doc/design/kanban-task-execution.md)。`item().task` 和 query 的 `task` 为相同宿主事实的投影，`phase` 过滤在服务端执行。
+
+事项支持 `request-control action=cancel` 的持久取消中状态及宿主停止回执；父项取消原子登记后代取消意图。`delete-item`、`delete-record` 保存逻辑删除墓碑，默认查询隐藏，`includeDeleted` 显式包含，原 ID 和审计保留。决策取消分为 `request-record-cancellation` 与结算后的 `cancel-record`。可选宿主端口 `controlRecord`、`taskFixes`、`cancelFix` 提供关联执行控制及修复澄清放弃；库不自行控制 Session。资源 `ownership` 独立于 `state`，归属未知或其他事项的资源必须保留，不得从归属未知推断执行已停止。
+
+看板 `lifecycle` 支持整体取消与等待删除屏障：`request-board-stop` 冻结新任务/计划/准入/派发/续办，`observe-board-stop` 保存收尾阶段。宿主可提供 `cancelBoard`、`requestBoardDeletion`；后者保存跨重启删除请求，默认 drain 等待原执行结束，或显式 cancel 后再删除。独立库不自装调度器，宿主扫描负责最终预检和自动删除，UI 显示请求已接纳与具体阻塞项。
+
+## 完整运行时
+
+普通接入使用一个工厂，直接获得可查询、提交命令、扫描和关停的看板实例：
+
+```ts
+import {createKanbanRuntime} from '@nestos/kanban/runtime';
+
+const kanban = await createKanbanRuntime({
+    fs: authorizedFS,
+    actor: authenticatedPrincipal,
+    authorize: authorizeOperation,
+    execution: executionAdapter, // Optional for boards without automated execution.
+});
+
+await kanban.scan();
+await kanban.dispose();
+```
+
+默认目录为 `/kanban`，可通过 `directory` 设置。`resources` 注入资源目录与权限校验，`activity` 注入执行活动来源，`onCommitted` 接入已有事件通道，`log` 接入诊断。库不自动创建定时器。返回值只包含看板语义操作，不暴露 store、journal、serviceFor 或原始 VFS。
+
+执行适配器只实现以下协议：
+
+```ts
+const executionAdapter = {
+    catalog: () => authorizedTargets(),
+    prepare: intent => prepareExternalRequest(intent),
+    submit: handle => submitExternalRequest(handle),
+    inspect: handle => inspectExternalReceipt(handle),
+    control: (handle, command) => controlExternalExecution(handle, command),
+};
+```
+
+- `ExecutionIntent` 包含稳定身份、作用域、目标与结构化上下文；`purpose` 区分规划和工作。规划返回 `ready/dependencies/reason` 及可选 estimate/subtasks，不引入宿主 Session/Flow DTO。
+- `ExecutionHandle` 是可持久化的 `{id,data?}`，由适配器解释。prepare 不能启动外部执行；运行时先保存句柄再 submit，恢复时使用原句柄 inspect。
+- 回执返回 `outcome`、可选 `result/executionId/code/controlCapabilities`。运行时保存并校验结果，通过 `kanban.results(boardId, dispatchId)` 读取授权产物。成功但结果未到达时保持 unknown；无正文结果显式返回 `result: null`。
+- 控制统一接收句柄与 `{operationId,action}`。不提供 control 时返回明确的 `TASK_CONTROL_UNSUPPORTED`，不能把取消意图当作取消完成。
+- 当前事项正文只放在 context.task 一处；决策只携带身份与修订，规划的 related 为摘要。执行依赖只传直接依赖的已验收产物。适配器按需通过授权查询读取额外内容。
+
+运行时负责幂等认领、回执丢失恢复、日志投影、产物归属、取消协调和删除屏障。宿主无需了解持久键，也无需自行编写这些状态机。完整接入、重启恢复、失败处理和取消验收见 `tests/public-runtime.test.ts`。
+
+## 自定义宿主集成
+
+`/integration` 面向需要自定义预设、交互确认或底层装配的受信任宿主，显式导出 `assembleKanbanRuntime`、协调组件与语义状态接口。它与普通 `/runtime` 入口分开；远程 HTTP/MCP 服务应只暴露经过授权的看板语义操作，不能透传 integration 对象。
+
+`KanbanCollaboration` 提供修复准备、冻结确认、接纳与决策快照，`collaborationRelations` 提供关联执行投影；适配器无需读取 fix、record-runs 或 task-reply 的内部持久键。宿主仍负责确认文案、通道交互和系统事件投影。
+
+`KanbanOperationRecord` 与 `coordinateOperation` 提供自定义业务操作的统一持久协调；执行请求和结果保持不透明，业务插件负责结果约束。只有正式“未启动”回执允许重试提交，连接中断只核对原身份。

package/dist/{activity-C6xDM-cg.d.cts → activity-BbC4sgKL.d.cts}

@@ -1,4 +1,4 @@
-import { u as KanbanExternalReference, y as KanbanItemQuery, x as KanbanItemPage, z as KanbanItemSummary, r as KanbanDispatch, T as KanbanService, v as KanbanFixSession, f as KanbanAutomationCatalog, b as KanbanAnalysisStatus } from './planning-CcFZYdIL.cjs';
+import { u as KanbanExternalReference, y as KanbanItemQuery, x as KanbanItemPage, z as KanbanItemSummary, r as KanbanDispatch, T as KanbanService, v as KanbanFixSession, f as KanbanAutomationCatalog, b as KanbanAnalysisStatus } from './planning-CHrOqQ6b.cjs';
 
 /** Hosts resolve opaque resources and execute records; the library owns no project policy. */
 interface KanbanRecordResource {
@@ -18,7 +18,7 @@ interface KanbanRecordExecution {
     boardId: string;
     rootItemId?: string;
     itemIds?: string[];
-    state: 'preparing' | 'running' | 'blocked' | 'review' | 'completed' | 'failed';
+    state: 'preparing' | 'running' | 'blocked' | 'review' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'pausing' | 'paused' | 'resuming' | 'unknown';
     createdAt: number;
     updatedAt: number;
     code?: string;
@@ -37,6 +37,7 @@ interface KanbanWorkResource {
     title: string;
     location: string;
     version: string;
+    ownership?: 'current' | 'other' | 'unknown';
     state: 'associated' | 'in-use' | 'retained' | 'cleanup-ready' | 'cleaned' | 'unknown';
     reasons: string[];
     properties: Array<{
@@ -118,6 +119,14 @@ interface KanbanDeletionPreview {
         sessionId?: string;
     }>;
     pendingItems: number;
+    pendingDeletion?: {
+        operationId: string;
+        mode: 'drain' | 'cancel';
+        phase: 'waiting' | 'ready' | 'blocked';
+        code?: string;
+    };
+    /** Display labels for items referenced by blockers and resources. */
+    itemTitles?: Record<string, string>;
     resources: Array<{
         itemId: string;
         resource: KanbanWorkResource;
@@ -201,6 +210,13 @@ interface KanbanExecutionSessionDetail {
 }
 /** Transport-facing service with optional authorized resource activity. */
 interface KanbanClient extends KanbanService {
+    cancelBoard?(boardId: string, request: {
+        operationId: string;
+        expectedRevision: number;
+    }): Promise<void>;
+    requestBoardDeletion?(boardId: string, request: KanbanDeletionRequest & {
+        mode: 'drain' | 'cancel';
+    }): Promise<void>;
     previewDeletion?(boardId: string): Promise<KanbanDeletionPreview>;
     deleteBoard?(boardId: string, request: KanbanDeletionRequest): Promise<void>;
     itemOperations?(boardId: string, itemId: string): Promise<KanbanItemOperations>;
@@ -215,6 +231,16 @@ interface KanbanClient extends KanbanService {
         operationId: string;
         content: string;
     }): Promise<void>;
+    taskFixes?(boardId: string, itemId: string): Promise<KanbanFixSession[]>;
+    cancelFix?(boardId: string, request: {
+        fixId: string;
+        operationId: string;
+    }): Promise<KanbanFixSession>;
+    controlRecord?(boardId: string, request: {
+        recordId: string;
+        operationId: string;
+        action: 'pause' | 'resume' | 'cancel';
+    }): Promise<void>;
     fixTask?(boardId: string, request: {
         itemId: string;
         operationId: string;

package/dist/{activity-Dw8DOw0L.d.ts → activity-Czlan5xW.d.ts}

@@ -1,4 +1,4 @@
-import { u as KanbanExternalReference, y as KanbanItemQuery, x as KanbanItemPage, z as KanbanItemSummary, r as KanbanDispatch, T as KanbanService, v as KanbanFixSession, f as KanbanAutomationCatalog, b as KanbanAnalysisStatus } from './planning-CcFZYdIL.js';
+import { u as KanbanExternalReference, y as KanbanItemQuery, x as KanbanItemPage, z as KanbanItemSummary, r as KanbanDispatch, T as KanbanService, v as KanbanFixSession, f as KanbanAutomationCatalog, b as KanbanAnalysisStatus } from './planning-CHrOqQ6b.js';
 
 /** Hosts resolve opaque resources and execute records; the library owns no project policy. */
 interface KanbanRecordResource {
@@ -18,7 +18,7 @@ interface KanbanRecordExecution {
     boardId: string;
     rootItemId?: string;
     itemIds?: string[];
-    state: 'preparing' | 'running' | 'blocked' | 'review' | 'completed' | 'failed';
+    state: 'preparing' | 'running' | 'blocked' | 'review' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'pausing' | 'paused' | 'resuming' | 'unknown';
     createdAt: number;
     updatedAt: number;
     code?: string;
@@ -37,6 +37,7 @@ interface KanbanWorkResource {
     title: string;
     location: string;
     version: string;
+    ownership?: 'current' | 'other' | 'unknown';
     state: 'associated' | 'in-use' | 'retained' | 'cleanup-ready' | 'cleaned' | 'unknown';
     reasons: string[];
     properties: Array<{
@@ -118,6 +119,14 @@ interface KanbanDeletionPreview {
         sessionId?: string;
     }>;
     pendingItems: number;
+    pendingDeletion?: {
+        operationId: string;
+        mode: 'drain' | 'cancel';
+        phase: 'waiting' | 'ready' | 'blocked';
+        code?: string;
+    };
+    /** Display labels for items referenced by blockers and resources. */
+    itemTitles?: Record<string, string>;
     resources: Array<{
         itemId: string;
         resource: KanbanWorkResource;
@@ -201,6 +210,13 @@ interface KanbanExecutionSessionDetail {
 }
 /** Transport-facing service with optional authorized resource activity. */
 interface KanbanClient extends KanbanService {
+    cancelBoard?(boardId: string, request: {
+        operationId: string;
+        expectedRevision: number;
+    }): Promise<void>;
+    requestBoardDeletion?(boardId: string, request: KanbanDeletionRequest & {
+        mode: 'drain' | 'cancel';
+    }): Promise<void>;
     previewDeletion?(boardId: string): Promise<KanbanDeletionPreview>;
     deleteBoard?(boardId: string, request: KanbanDeletionRequest): Promise<void>;
     itemOperations?(boardId: string, itemId: string): Promise<KanbanItemOperations>;
@@ -215,6 +231,16 @@ interface KanbanClient extends KanbanService {
         operationId: string;
         content: string;
     }): Promise<void>;
+    taskFixes?(boardId: string, itemId: string): Promise<KanbanFixSession[]>;
+    cancelFix?(boardId: string, request: {
+        fixId: string;
+        operationId: string;
+    }): Promise<KanbanFixSession>;
+    controlRecord?(boardId: string, request: {
+        recordId: string;
+        operationId: string;
+        action: 'pause' | 'resume' | 'cancel';
+    }): Promise<void>;
     fixTask?(boardId: string, request: {
         itemId: string;
         operationId: string;

package/dist/activity-module-DaO1Rry0.d.cts

@@ -0,0 +1,22 @@
+import { p as KanbanSessionActivityQuery, t as KanbanSessionItemPage, r as KanbanSessionDetailQuery, d as KanbanExecutionSessionDetail } from './activity-BbC4sgKL.cjs';
+import { K as KanbanModuleHandle } from './module-Ca9L3qCn.cjs';
+import { K as KanbanModuleOptions } from './ports-GQy0x-RI.cjs';
+import { K as KanbanSessionSource } from './activity-ports-Dqxa86zT.cjs';
+
+interface KanbanSessionActivityOptions {
+    source: KanbanSessionSource;
+    now?: () => number;
+}
+
+interface KanbanActivityModuleOptions extends KanbanModuleOptions {
+    executionSessions?: KanbanSessionActivityOptions;
+    referenceSystem: string;
+}
+interface KanbanActivityHandle extends KanbanModuleHandle {
+    queryActivity: (boardId: string, query?: KanbanSessionActivityQuery) => Promise<KanbanSessionItemPage>;
+    executionSession: (boardId: string, itemId: string, query?: KanbanSessionDetailQuery) => Promise<KanbanExecutionSessionDetail>;
+}
+/** Application integrations stay outside the portable core. */
+declare function createKanbanActivityModule(options: KanbanActivityModuleOptions): KanbanActivityHandle;
+
+export { type KanbanActivityHandle as K, type KanbanActivityModuleOptions as a, type KanbanSessionActivityOptions as b, createKanbanActivityModule as c };

package/dist/activity-module-T22wliZu.d.ts

@@ -0,0 +1,22 @@
+import { p as KanbanSessionActivityQuery, t as KanbanSessionItemPage, r as KanbanSessionDetailQuery, d as KanbanExecutionSessionDetail } from './activity-Czlan5xW.js';
+import { K as KanbanModuleHandle } from './module-CYfE7YhM.js';
+import { K as KanbanModuleOptions } from './ports-B0McVg7B.js';
+import { K as KanbanSessionSource } from './activity-ports-cxfrelaL.js';
+
+interface KanbanSessionActivityOptions {
+    source: KanbanSessionSource;
+    now?: () => number;
+}
+
+interface KanbanActivityModuleOptions extends KanbanModuleOptions {
+    executionSessions?: KanbanSessionActivityOptions;
+    referenceSystem: string;
+}
+interface KanbanActivityHandle extends KanbanModuleHandle {
+    queryActivity: (boardId: string, query?: KanbanSessionActivityQuery) => Promise<KanbanSessionItemPage>;
+    executionSession: (boardId: string, itemId: string, query?: KanbanSessionDetailQuery) => Promise<KanbanExecutionSessionDetail>;
+}
+/** Application integrations stay outside the portable core. */
+declare function createKanbanActivityModule(options: KanbanActivityModuleOptions): KanbanActivityHandle;
+
+export { type KanbanActivityHandle as K, type KanbanActivityModuleOptions as a, type KanbanSessionActivityOptions as b, createKanbanActivityModule as c };

package/dist/activity-ports-Dqxa86zT.d.cts

@@ -0,0 +1,12 @@
+import { j as KanbanBoard, w as KanbanItem, a7 as KanbanWorkflowState } from './planning-CHrOqQ6b.cjs';
+import { q as KanbanSessionAssociation, c as KanbanExecutionSession } from './activity-BbC4sgKL.cjs';
+
+interface KanbanSessionSource {
+    /** Cold, authorized relations only; never submit or restore execution while listing. */
+    related?(board: KanbanBoard, item: KanbanItem, workflow: KanbanWorkflowState): Promise<KanbanSessionAssociation[]>;
+    authorizeBinding?(board: KanbanBoard, sessionId: string): Promise<void>;
+    /** Must check access within the supplied board's user/project and authority. */
+    inspect(board: KanbanBoard, sessionId: string): Promise<Omit<KanbanExecutionSession, 'recent'>>;
+}
+
+export type { KanbanSessionSource as K };

package/dist/activity-ports-cxfrelaL.d.ts

@@ -0,0 +1,12 @@
+import { j as KanbanBoard, w as KanbanItem, a7 as KanbanWorkflowState } from './planning-CHrOqQ6b.js';
+import { q as KanbanSessionAssociation, c as KanbanExecutionSession } from './activity-Czlan5xW.js';
+
+interface KanbanSessionSource {
+    /** Cold, authorized relations only; never submit or restore execution while listing. */
+    related?(board: KanbanBoard, item: KanbanItem, workflow: KanbanWorkflowState): Promise<KanbanSessionAssociation[]>;
+    authorizeBinding?(board: KanbanBoard, sessionId: string): Promise<void>;
+    /** Must check access within the supplied board's user/project and authority. */
+    inspect(board: KanbanBoard, sessionId: string): Promise<Omit<KanbanExecutionSession, 'recent'>>;
+}
+
+export type { KanbanSessionSource as K };

package/dist/activity.cjs

@@ -1,288 +1,16 @@
-"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; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkIUI5CI2Scjs = require('./chunk-IUI5CI2S.cjs');
-require('./chunk-L44TM4EE.cjs');
-require('./chunk-4XF6LQSU.cjs');
-
-
-
-
-var _chunk4KF7KUAIcjs = require('./chunk-4KF7KUAI.cjs');
-
-
-var _chunk2YFPV5GFcjs = require('./chunk-2YFPV5GF.cjs');
-require('./chunk-KYNYPKKH.cjs');
-require('./chunk-PSKQAFDF.cjs');
 
-
-
-var _chunk6MN3H3YFcjs = require('./chunk-6MN3H3YF.cjs');
-require('./chunk-LSE6JG5I.cjs');
-
-// src/session-activity-query.ts
-async function querySessionItems(core, boardId, input, project) {
-  const { execution = "all", ...query } = input;
-  if (!["all", "running", "recent", "active"].includes(execution)) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("INVALID_EXECUTION_FILTER");
-  if (execution === "all") {
-    const page2 = await core.query(boardId, query);
-    return { ...page2, items: await project(page2.items) };
-  }
-  const { cursor, limit = 50, ...filters } = query;
-  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("INVALID_PAGE_SIZE");
-  let page = await core.query(boardId, { ...filters, limit: 200 }), rows = [...page.items];
-  const revision = page.revision;
-  while (page.nextCursor) {
-    if (rows.length >= 1e4) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("ACTIVITY_QUERY_LIMIT");
-    page = await core.query(boardId, { ...filters, limit: 200, cursor: page.nextCursor });
-    if (page.revision !== revision) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("CURSOR_STALE");
-    rows.push(...page.items);
-  }
-  const matching = (await project(rows)).filter((row) => matchesExecution(row, execution));
-  if ((await core.query(boardId, { ...filters, limit: 1 })).revision !== revision) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("CURSOR_STALE");
-  const scope = _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify({ filters, execution, limit })), signature = _chunk6MN3H3YFcjs.sha256HexSync.call(void 0, JSON.stringify(matching.map((row) => row.id)));
-  let start = 0;
-  if (cursor) {
-    let saved;
-    try {
-      saved = JSON.parse(cursor);
-    } catch (e) {
-      throw new (0, _chunk2YFPV5GFcjs.KanbanError)("INVALID_CURSOR");
-    }
-    if (saved.scope !== scope) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("CURSOR_SCOPE_MISMATCH");
-    if (saved.revision !== revision || saved.signature !== signature) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("CURSOR_STALE");
-    start = matching.findIndex((row) => row.id === saved.after) + 1;
-    if (start < 1) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("INVALID_CURSOR");
-  }
-  const items = matching.slice(start, start + limit);
-  return { revision, total: matching.length, items, ...start + items.length < matching.length ? { nextCursor: JSON.stringify({ scope, revision, signature, after: items.at(-1).id }) } : {} };
-}
-function matchesExecution(row, filter) {
-  const session = row.execution;
-  if (!session || session.stale) return false;
-  return filter === "running" ? session.state === "running" : filter === "recent" ? session.recent : session.state === "running" || session.recent;
-}
-
-// src/session-relations.ts
-function sessionAssociations(item, bindings, workflow) {
-  return [...bindings.map((ref) => {
-    const dispatch = workflow.dispatches[_nullishCoalesce(ref.revision, () => ( ""))];
-    const execution = _optionalChain([dispatch, 'optionalAccess', _ => _.itemId]) === item.id ? {
-      id: dispatch.id,
-      purpose: "execution",
-      dispatchId: dispatch.id,
-      attempt: dispatch.attempt,
-      outcome: dispatch.outcome,
-      createdAt: dispatch.preparedAt,
-      code: dispatch.code,
-      ...dispatch.continuation ? { previousDispatchId: dispatch.continuation.previousDispatchId } : {}
-    } : void 0;
-    return { sessionId: ref.id, purpose: "execution", ...execution ? { execution } : {} };
-  }), ...item.participants.filter((row) => !bindings.some((ref) => ref.id === row.sessionId)).map((row) => ({ sessionId: row.sessionId, purpose: "discussion" }))];
-}
-async function projectRelatedSessions(associations, currentId, inspect) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const row of associations) {
-    let group = grouped.get(row.sessionId);
-    if (!group) grouped.set(row.sessionId, group = { purposes: /* @__PURE__ */ new Set(), executions: /* @__PURE__ */ new Map() });
-    group.purposes.add(row.purpose);
-    if (row.execution) group.executions.set(row.execution.id, { ...group.executions.get(row.execution.id), ...row.execution });
-  }
-  const rows = [], entries = [...grouped];
-  let next = 0;
-  await Promise.all(Array.from({ length: Math.min(entries.length, 8) }, async () => {
-    while (next < entries.length) {
-      const [sessionId, group] = entries[next++], state = await inspect(sessionId);
-      rows.push({
-        ...state,
-        current: sessionId === currentId,
-        purposes: [...group.purposes].sort(),
-        executions: [...group.executions.values()].sort((a, b) => (_nullishCoalesce(a.createdAt, () => ( 0))) - (_nullishCoalesce(b.createdAt, () => ( 0))) || a.id.localeCompare(b.id))
-      });
-    }
-  }));
-  return rows.sort((a, b) => Number(b.current) - Number(a.current) || a.sessionId.localeCompare(b.sessionId));
-}
-
-// src/session-activity.ts
-function executionBindings(refs, referenceSystem) {
-  return (_nullishCoalesce(refs, () => ( []))).filter((ref) => ref.system === referenceSystem);
-}
-function currentBinding(refs, itemId, workflow, referenceSystem) {
-  const binding = executionBindings(refs, referenceSystem).at(-1), latest = Object.values(workflow.dispatches).filter((dispatch) => dispatch.itemId === itemId).sort((a, b) => b.attempt - a.attempt)[0];
-  if (!binding || !latest || binding.revision === latest.id) return binding;
-  return ["prepared", "running", "unknown", "succeeded"].includes(latest.outcome) || workflow.dispatches[_nullishCoalesce(binding.revision, () => ( ""))] ? void 0 : binding;
-}
-function createKanbanSessionActivity(core, options, log, referenceSystem) {
-  const inspect = createSessionInspector(options, log);
-  const project = async (boardId, rows) => {
-    if (!rows.some((row) => executionBindings(row.externalRefs, referenceSystem).length)) return rows;
-    const [board, workflow] = await Promise.all([boardMetadata(core, boardId), core.workflow(boardId)]), bindings = new Map(rows.map((row) => [row.id, currentBinding(row.externalRefs, row.id, workflow, referenceSystem)]));
-    const ids = [...new Set([...bindings.values()].flatMap((ref) => ref ? [ref.id] : []))], states = /* @__PURE__ */ new Map();
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(ids.length, 8) }, async () => {
-      while (next < ids.length) {
-        const id = ids[next++];
-        states.set(id, await inspect(board, id));
-      }
-    }));
-    return rows.map((row) => {
-      const binding = bindings.get(row.id);
-      return { ...row, ...binding ? { execution: states.get(binding.id) } : {} };
-    });
-  };
-  return {
-    queryActivity: (boardId, query = {}) => querySessionItems(core, boardId, query, (rows) => project(boardId, rows)),
-    async executionSession(boardId, itemId, query = {}) {
-      const started = Date.now();
-      if (!query || typeof query !== "object" || Array.isArray(query) || Object.keys(query).some((key) => key !== "includeRelated") || query.includeRelated !== void 0 && typeof query.includeRelated !== "boolean") throw new (0, _chunk2YFPV5GFcjs.KanbanError)("INVALID_QUERY");
-      const { item } = await core.item(boardId, itemId), bindings = executionBindings(item.externalRefs, referenceSystem);
-      if (!bindings.length && !query.includeRelated) return { history: [] };
-      const [board, workflow] = await Promise.all([boardMetadata(core, boardId), core.workflow(boardId)]), last = currentBinding(item.externalRefs, itemId, workflow, referenceSystem);
-      let sessionsCode;
-      const related = query.includeRelated ? await _optionalChain([options, 'optionalAccess', _2 => _2.source, 'access', _3 => _3.related, 'optionalCall', _4 => _4(board, item, workflow), 'access', _5 => _5.catch, 'call', _6 => _6((error) => {
-        const candidate = _optionalChain([error, 'optionalAccess', _7 => _7.code]);
-        sessionsCode = candidate && /^[A-Z][A-Z0-9_]{0,79}$/.test(candidate) ? candidate : "SESSION_RELATIONS_FAILED";
-        try {
-          log({ operationId: _chunk6MN3H3YFcjs.randomUUID.call(void 0, ), stage: "session.relations", result: "failure", code: sessionsCode, durationMs: Date.now() - started });
-        } catch (e2) {
-        }
-        return [];
-      })]) : [];
-      const sessions = query.includeRelated ? await projectRelatedSessions([
-        ...sessionAssociations(item, bindings, workflow),
-        ..._nullishCoalesce(related, () => ( []))
-      ], _optionalChain([last, 'optionalAccess', _8 => _8.id]), (id) => inspect(board, id)) : void 0;
-      return {
-        current: last ? await _asyncNullishCoalesce(await _asyncOptionalChain([sessions, 'optionalAccess', async _9 => _9.find, 'call', async _10 => _10((row) => row.sessionId === last.id)]), async () => ( await inspect(board, last.id))) : void 0,
-        history: bindings.map((ref) => ({ sessionId: ref.id, bindingId: ref.revision, current: ref === last })).reverse(),
-        ...sessions ? { sessions } : {},
-        ...sessionsCode ? { sessionsCode } : {}
-      };
-    },
-    validate: (board, command, actor) => validateBinding(core, options, board, command, actor, referenceSystem)
-  };
-}
-function createSessionInspector(options, log) {
-  const now = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.now]), () => ( Date.now)), cache = /* @__PURE__ */ new Map();
-  return async (board, sessionId) => {
-    const started = now(), key = JSON.stringify([board.id, sessionId]);
-    try {
-      if (!options) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("EXECUTION_SESSION_UNAVAILABLE");
-      const row = await options.source.inspect(board, sessionId);
-      if (row.sessionId !== sessionId) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("SESSION_ACTIVITY_SCOPE_MISMATCH");
-      const stale = row.stale || row.observedAt === void 0 || now() - row.observedAt > 9e4;
-      const value = {
-        sessionId,
-        ...typeof row.resourceId === "string" && row.resourceId.length <= 4096 && !row.resourceId.includes("\0") ? { resourceId: row.resourceId } : {},
-        title: _optionalChain([row, 'access', _12 => _12.title, 'optionalAccess', _13 => _13.slice, 'call', _14 => _14(0, 256)]),
-        state: row.state,
-        createdAt: row.createdAt,
-        lastActivityAt: row.lastActivityAt,
-        observedAt: row.observedAt,
-        stale,
-        recent: !stale && row.lastActivityAt !== void 0 && row.lastActivityAt <= now() && now() - row.lastActivityAt <= 6e5,
-        ...row.code && /^[A-Z][A-Z0-9_]{0,79}$/.test(row.code) ? { code: row.code } : {}
-      };
-      if (cache.size >= 256) cache.delete(cache.keys().next().value);
-      cache.set(key, value);
-      return value;
-    } catch (error) {
-      const candidate = _optionalChain([error, 'optionalAccess', _15 => _15.code]), code = candidate && /^[A-Z][A-Z0-9_]{0,79}$/.test(candidate) ? candidate : "SESSION_ACTIVITY_FAILED";
-      try {
-        log({ operationId: _chunk6MN3H3YFcjs.randomUUID.call(void 0, ), sessionId, stage: "session.activity", result: "failure", code, durationMs: now() - started });
-      } catch (e3) {
-      }
-      const prior = ["EIO", "ETIMEDOUT", "ECONNRESET", "ECONNREFUSED", "SESSION_ACTIVITY_FAILED"].includes(code) ? cache.get(key) : void 0;
-      return { ...prior, sessionId, state: _nullishCoalesce(_optionalChain([prior, 'optionalAccess', _16 => _16.state]), () => ( "unknown")), stale: true, recent: false, code };
-    }
-  };
-}
-async function boardMetadata(core, boardId) {
-  const board = await _asyncNullishCoalesce((await core.catalog()).find((board2) => board2.id === boardId), async () => ( await core.read(boardId)));
-  return { ...board, items: [] };
-}
-async function validateBinding(core, options, board, command, actor, referenceSystem) {
-  if (_optionalChain([command, 'optionalAccess', _17 => _17.type]) !== "link-reference" || command.reference.system !== referenceSystem) return;
-  if (!options || !command.reference.revision) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("EXECUTION_SESSION_UNAVAILABLE");
-  const item = board.items.find((item2) => item2.id === command.itemId);
-  if (!item) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("ITEM_NOT_FOUND");
-  const key = _chunk4KF7KUAIcjs.principalKey.call(void 0, _chunk4KF7KUAIcjs.principal.call(void 0, actor)), coordinator = _optionalChain([board, 'access', _18 => _18.members, 'optionalAccess', _19 => _19.some, 'call', _20 => _20((member) => _chunk4KF7KUAIcjs.principalKey.call(void 0, member) === key && _optionalChain([member, 'access', _21 => _21.roles, 'optionalAccess', _22 => _22.includes, 'call', _23 => _23("coordinator")]))]);
-  if (!coordinator && _optionalChain([item, 'access', _24 => _24.owner, 'optionalAccess', _25 => _25.principalId]) !== key && !(item.owner === void 0 && _chunk4KF7KUAIcjs.candidates.call(void 0, board, item).some((candidate) => _chunk4KF7KUAIcjs.principalKey.call(void 0, candidate) === key))) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("EXECUTION_SESSION_ASSIGNMENT_DENIED");
-  const active = Object.values((await core.workflow(board.id)).dispatches).filter((dispatch) => dispatch.itemId === item.id).sort((a, b) => b.attempt - a.attempt)[0];
-  if (active && command.reference.revision !== active.id) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("EXECUTION_SESSION_LOCKED");
-  if (active && executionBindings(item.externalRefs, referenceSystem).some((ref) => ref.revision === active.id && ref.id !== command.reference.id)) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("EXECUTION_SESSION_LOCKED");
-  if (options.source.authorizeBinding) return options.source.authorizeBinding(board, command.reference.id);
-  const state = await options.source.inspect(board, command.reference.id);
-  if (state.sessionId !== command.reference.id || state.stale) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("EXECUTION_SESSION_UNAVAILABLE");
-}
-
-// src/activity-module.ts
-function createKanbanActivityModule(options) {
-  const { executionSessions, referenceSystem, ...core } = options;
-  let activity;
-  const service = _chunkIUI5CI2Scjs.createKanbanModule.call(void 0, {
-    ...core,
-    authorize: async (input) => {
-      await core.authorize(input);
-      await activity.validate(input.board, input.command, input.actor);
-    }
-  });
-  activity = createKanbanSessionActivity(service, executionSessions, core.log, referenceSystem);
-  let stopping = false;
-  const pending = /* @__PURE__ */ new Set();
-  const track = (run) => {
-    if (stopping) return Promise.reject(new (0, _chunk2YFPV5GFcjs.KanbanError)("SERVICE_STOPPING"));
-    const work = Promise.resolve().then(run).finally(() => {
-      pending.delete(work);
-    });
-    pending.add(work);
-    return work;
-  };
-  const quiesce = async () => {
-    stopping = true;
-    await Promise.allSettled([...pending]);
-    await service.quiesce();
-  };
-  return {
-    ...forwardCore(service, track),
-    queryActivity: (...args) => track(() => activity.queryActivity(...args)),
-    executionSession: (...args) => track(() => activity.executionSession(...args)),
-    related: (sessionId) => track(() => relatedBoards(service, referenceSystem, sessionId)),
-    quiesce,
-    dispose: quiesce
-  };
-}
-function forwardCore(service, track) {
-  return {
-    create: (input) => track(() => service.create(input)),
-    read: (id) => track(() => service.read(id)),
-    list: () => track(() => service.list()),
-    catalog: () => track(() => service.catalog()),
-    execute: (id, request) => track(() => service.execute(id, request)),
-    events: (id, after, limit) => track(() => service.events(id, after, limit)),
-    query: (id, query) => track(() => service.query(id, query)),
-    item: (id, item) => track(() => service.item(id, item)),
-    overview: (id) => track(() => service.overview(id)),
-    scan: () => track(() => service.scan()),
-    workflow: (id) => track(() => service.workflow(id)),
-    resolve: (reference) => track(() => service.resolve(reference)),
-    suggest: (id, query) => track(() => service.suggest(id, query)),
-    records: (id, query) => track(() => service.records(id, query)),
-    record: (id, record) => track(() => service.record(id, record)),
-    currentPrincipal: () => track(() => service.currentPrincipal())
-  };
-}
-async function relatedBoards(service, referenceSystem, sessionId) {
-  const boards = await service.related(sessionId);
-  for (const board of await service.catalog()) {
-    if (boards.some((old) => old.id === board.id)) continue;
-    const matches = await service.query(board.id, { view: "all", reference: { system: referenceSystem, id: sessionId }, limit: 1 });
-    if (matches.total) boards.push(await service.read(board.id));
-  }
-  return boards;
-}
+var _chunk5Q7WB63Acjs = require('./chunk-5Q7WB63A.cjs');
+require('./chunk-DINLR6E6.cjs');
+require('./chunk-EYTVC2H5.cjs');
+require('./chunk-4XF6LQSU.cjs');
+require('./chunk-RBOER6EW.cjs');
+require('./chunk-7KDOTBRX.cjs');
+require('./chunk-RSH6QSEC.cjs');
+require('./chunk-AOHQCX7K.cjs');
 
 
 
-exports.createKanbanActivityModule = createKanbanActivityModule; exports.querySessionItems = querySessionItems;
+exports.createKanbanActivityModule = _chunk5Q7WB63Acjs.createKanbanActivityModule; exports.querySessionItems = _chunk5Q7WB63Acjs.querySessionItems;
 //# sourceMappingURL=activity.cjs.map