@nestos/kanban 0.5.1 → 0.5.2

package/dist/runtime/integration.d.ts

@@ -0,0 +1,658 @@
+import * as _nestos_vfs_core from '@nestos/vfs-core';
+import { IFileSystem } from '@nestos/vfs-core';
+import { b as KanbanJournalOptions, a as KanbanRuntimeDiagnostic, K as KanbanResourceCatalog, c as KanbanWorkLogOptions, d as KanbanReferencePolicy } from '../ports-ykGiNUSx.js';
+export { e as defaultReferences } from '../ports-ykGiNUSx.js';
+import { d as KanbanArtifactRef, T as KanbanService, o as KanbanCommand, K as KanbanActor, s as KanbanEstimate, j as KanbanBoard, w as KanbanItem, u as KanbanExternalReference, J as KanbanProjectRecord, b as KanbanAnalysisStatus, M as KanbanRecordActivity, P as KanbanRecordQuery, O as KanbanRecordPage, f as KanbanAutomationCatalog, v as KanbanFixSession, r as KanbanDispatch, a7 as KanbanWorkflowState, R as KanbanReferenceTarget, Y as KanbanSuggestionQuery, X as KanbanSuggestionPage, I as KanbanPrincipal, l as KanbanBoardInput, m as KanbanBoardSummary, S as KanbanRequest, t as KanbanEvent, y as KanbanItemQuery, x as KanbanItemPage, a1 as KanbanTaskProjection, c as KanbanArchivedItem, E as KanbanOverview } from '../planning-CHrOqQ6b.js';
+import { K as KanbanClient, n as KanbanRecordRunRequest, l as KanbanRecordExecution, a as KanbanDeletionPreview, b as KanbanDeletionRequest, i as KanbanItemResourceCatalog, h as KanbanItemOperations, g as KanbanItemOperationRequest, f as KanbanItemOperationBinding, z as KanbanWorkResourceQuery, x as KanbanWorkResource, y as KanbanWorkResourceCleanup, p as KanbanSessionActivityQuery, t as KanbanSessionItemPage, r as KanbanSessionDetailQuery, d as KanbanExecutionSessionDetail } from '../activity-Czlan5xW.js';
+import { b as KanbanExecutionPort, K as KanbanExecutionBridgeOptions } from '../execution-bridge-rk0uVy_n.js';
+import { K as KanbanActivityHandle, a as KanbanActivityModuleOptions } from '../activity-module-T22wliZu.js';
+import { e as KanbanStore } from '../ports-B0McVg7B.js';
+import '../module-CYfE7YhM.js';
+import '../activity-ports-cxfrelaL.js';
+import '../discovery-D60yrjej.js';
+
+declare class KanbanAutomationJournal {
+    private readonly fs;
+    private readonly options;
+    private readonly writes;
+    readonly directory: string;
+    readonly indexPath: string;
+    private readonly path;
+    private readonly artifactScheme;
+    constructor(fs: IFileSystem, options?: KanbanJournalOptions);
+    diagnostic(event: KanbanRuntimeDiagnostic): void;
+    open(): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+    getMany<T>(keys: string[]): Promise<Array<T | undefined>>;
+    findForBoard<T>(family: string, boardId: string, matches: (value: T) => boolean): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    find<T>(keyPrefix: string, matches: (value: T, key: string) => boolean): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    update<T>(key: string, change: (previous: T | undefined) => T): Promise<T>;
+    drain(): Promise<void>;
+    claim(key: string): Promise<boolean>;
+    private commit;
+    artifact(dispatchId: string, value: unknown): Promise<KanbanArtifactRef[]>;
+    verify(outputs: KanbanArtifactRef[], dispatchId?: string): Promise<boolean>;
+}
+
+/** Unknown responses retain the frozen request; only a definite CAS rejection can rebase. */
+declare function journalCommand(journal: KanbanAutomationJournal, service: Pick<KanbanService, 'read' | 'execute'>, boardId: string, key: string, command: KanbanCommand): Promise<void>;
+
+/** Completing a composite never starts another execution or substitutes for child acceptance. */
+declare function completeCompositePlans(service: KanbanService, journal: KanbanAutomationJournal, boardId: string, serviceFor: (actor: KanbanActor) => KanbanService): Promise<void>;
+
+interface AnalysisSubtask {
+    key: string;
+    title: string;
+    responsibility: string;
+    acceptance: string;
+    dependsOn: string[];
+    estimate?: KanbanEstimate;
+}
+interface Input {
+    id: string;
+    reason: string;
+    dependencies: string[];
+    subtasks: AnalysisSubtask[];
+}
+declare function validateSubtasks(value: unknown): AnalysisSubtask[] | undefined;
+/** The model supplies local keys; the host owns stable identities, resource inheritance and publication. */
+declare function adoptDecomposition(journal: KanbanAutomationJournal, board: KanbanBoard, parent: KanbanItem, input: Input, service: KanbanService, inherited?: KanbanExternalReference[]): Promise<void>;
+
+interface Options$3 {
+    requiresItemResource?(board: KanbanBoard): boolean;
+    service: KanbanClient;
+    journal: KanbanAutomationJournal;
+    resources: KanbanResourceCatalog;
+    log(input: {
+        operationId: string;
+        boardId: string;
+        stage: string;
+        result: 'success' | 'failure';
+        code?: string;
+        durationMs: number;
+    }): void;
+}
+/** A restartable projection from an approved decision into work on its chosen board. */
+declare function createRecordExecution(options: Options$3): {
+    itemResources: (boardId: string, parentId?: string) => Promise<{
+        resources: {
+            reference: KanbanExternalReference;
+            label: string;
+        }[];
+        selected: KanbanExternalReference | undefined;
+        readonly: boolean;
+        required: boolean;
+    }>;
+    recordResources: () => Promise<{
+        reference: KanbanExternalReference;
+        label: string;
+    }[]>;
+    runRecord: (boardId: string, request: KanbanRecordRunRequest) => Promise<KanbanRecordExecution>;
+    controlRecord: (boardId: string, request: {
+        recordId: string;
+        operationId: string;
+        action: "pause" | "resume" | "cancel";
+    }) => Promise<void>;
+    recordExecutions: (boardId: string, recordId: string) => Promise<KanbanRecordExecution[]>;
+    scan(): Promise<void>;
+    quiesce(): Promise<void>;
+};
+declare function validateResourceReferences(resources: KanbanResourceCatalog, record: Pick<KanbanProjectRecord, 'externalRefs'>): Promise<void>;
+
+interface RecordControl {
+    boardId?: string;
+    recordId?: string;
+    operationId: string;
+    action: 'pause' | 'resume' | 'cancel';
+    controls: Record<string, string>;
+    settled?: boolean;
+}
+declare const recordControlKey: (board: string, record: string) => string;
+/** Only already materialized work is controlled; cancellation never creates missing work. */
+declare function advanceRecordControl(service: KanbanClient, journal: KanbanAutomationJournal, run: KanbanRecordExecution & {
+    sourceBoardId: string;
+}, control: RecordControl): Promise<KanbanRecordExecution['state']>;
+declare function requestRecordControl(service: KanbanClient, journal: KanbanAutomationJournal, boardId: string, request: {
+    recordId: string;
+    operationId: string;
+    action: RecordControl['action'];
+}): Promise<void>;
+
+declare function safeCode(error: unknown, fallback: string): string;
+
+interface AnalysisJournalEntry {
+    id: string;
+    itemRevision: number;
+    signature: string;
+    phase: 'prepared' | 'submitting' | 'settled';
+    status: KanbanAnalysisStatus;
+    terminalOutcome?: 'succeeded' | 'failed' | 'cancelled';
+}
+/** Rebuild legacy history once; the hash proves board/item scope even when item IDs overlap. */
+declare function analysisHistory<T extends AnalysisJournalEntry = AnalysisJournalEntry>(journal: KanbanAutomationJournal, boardId: string, itemId: string): Promise<T[]>;
+
+interface Options$2 {
+    service: KanbanClient;
+    journal: KanbanAutomationJournal;
+}
+type Blocker = KanbanDeletionPreview['blockers'][number];
+declare function boardDeletionBlockers({ service, journal }: Options$2, boardId: string, items?: Array<{
+    id: string;
+    title: string;
+}>): Promise<Blocker[]>;
+declare function deletionPreview(options: Options$2, boardId: string): Promise<KanbanDeletionPreview>;
+
+/** A retained tombstone preserves audit and resource provenance without owning Sessions. */
+declare function createBoardDeletion(options: Options$2): {
+    previewDeletion: (id: string) => Promise<KanbanDeletionPreview>;
+    assertSettled: (id: string) => Promise<void>;
+    deleteBoard: (id: string, request: KanbanDeletionRequest) => Promise<void>;
+    cancelBoard: (board: string, request: {
+        operationId: string;
+        expectedRevision: number;
+    }) => Promise<void>;
+    requestBoardDeletion: (board: string, request: KanbanDeletionRequest & {
+        mode: "drain" | "cancel";
+    }) => Promise<void>;
+    preparePending: () => Promise<void>;
+    resumePending: () => Promise<void>;
+};
+/** Concurrent admissions share an exclusive deletion barrier; queries never wait for scans. */
+declare function withBoardDeletion<T extends KanbanClient & {
+    quiesce?(): Promise<void>;
+    dispose?(): Promise<void>;
+}>(service: T, deletion: ReturnType<typeof createBoardDeletion>): T & Pick<typeof deletion, 'previewDeletion' | 'deleteBoard'>;
+
+interface WorkLogFact extends KanbanRecordActivity {
+    references?: KanbanExternalReference[];
+    summary?: string;
+}
+/** A recoverable read projection; it never appends commands or grows coordination state. */
+declare class KanbanWorkLog {
+    private readonly options;
+    private readonly store;
+    private readonly projection;
+    private readonly log;
+    constructor(fs: IFileSystem, options?: KanbanWorkLogOptions);
+    open(): Promise<void>;
+    synchronize(boardId: string, source: KanbanService): Promise<void>;
+    append(source: KanbanService, boardId: string, itemId: string, fact: WorkLogFact): Promise<void>;
+    record(source: KanbanService, boardId: string, id: string): Promise<KanbanProjectRecord>;
+    records(source: KanbanService, boardId: string, query?: KanbanRecordQuery): Promise<KanbanRecordPage>;
+}
+
+interface AnalysisResult {
+    ready: boolean;
+    dependencies: string[];
+    reason: string;
+    estimate?: KanbanEstimate;
+    subtasks?: AnalysisSubtask[];
+}
+interface KanbanAnalysisObservation {
+    state: 'running' | 'unknown' | 'succeeded' | 'failed' | 'cancelled';
+    output?: unknown;
+    code?: string;
+}
+interface KanbanAnalysisPort<Target = KanbanExternalReference, Input = unknown> {
+    prepare(input: {
+        id: string;
+        board: KanbanBoard;
+        item: KanbanItem;
+        target: Target;
+    }): Promise<Input>;
+    prepareExecution(id: string, input: Input): Promise<void>;
+    submit(input: Input): Promise<void>;
+    inspect(id: string, input: Input): Promise<KanbanAnalysisObservation>;
+}
+interface KanbanAnalysisOptions<Target = KanbanExternalReference, Input = unknown> {
+    journal: KanbanAutomationJournal;
+    port: KanbanAnalysisPort<Target, Input>;
+    active(): boolean;
+    inheritReferences?(references: readonly KanbanExternalReference[]): KanbanExternalReference[];
+    onSettled?(input: {
+        boardId: string;
+        id: string;
+        item: KanbanItem;
+        request: Input;
+        outcome: 'succeeded' | 'failed' | 'cancelled';
+        code?: string;
+    }): Promise<void>;
+    log(input: {
+        operationId: string;
+        stage: string;
+        result: 'success' | 'failure';
+        code?: string;
+        durationMs: number;
+    }): void;
+}
+declare function analysisStatus<Input = unknown>(journal: KanbanAutomationJournal, board: string, item: string): Promise<KanbanAnalysisStatus | null>;
+declare function analysisSignature(board: KanbanBoard): string;
+declare function analyzeItem<Target, Input>(options: KanbanAnalysisOptions<Target, Input>, board: KanbanBoard, item: KanbanItem, target: Target | undefined, service: KanbanService): Promise<void>;
+declare function parseAnalysis(output: unknown): AnalysisResult;
+
+interface KanbanExecutorContext {
+    boardId: string;
+    service: KanbanService;
+    dependencies(item: KanbanItem): Promise<unknown>;
+}
+interface KanbanAutomationOptions {
+    fs: IFileSystem;
+    directory: string;
+    service: KanbanService;
+    journal: KanbanAutomationJournal;
+    workLog?: KanbanWorkLog;
+    serviceFor(actor: KanbanActor): KanbanService;
+    catalog(): Promise<KanbanAutomationCatalog>;
+    executor(context: KanbanExecutorContext): Promise<KanbanExecutionPort>;
+    analyze?(board: KanbanBoard, item: KanbanItem, service: KanbanService, active: () => boolean): Promise<void>;
+    controls?(board: KanbanBoard, service: KanbanService): Promise<void>;
+    drain?(board: KanbanBoard, service: KanbanService): Promise<void>;
+    executionReference?: KanbanExecutionBridgeOptions['executionReference'];
+    log(event: KanbanRuntimeDiagnostic & {
+        result: 'success' | 'failure';
+    }): void;
+}
+declare function createKanbanAutomation(options: KanbanAutomationOptions): {
+    scan: () => Promise<void>;
+    quiesce(): Promise<void>;
+    automationCatalog: () => Promise<KanbanAutomationCatalog>;
+    analysisStatus: (board: string, item: string) => Promise<KanbanAnalysisStatus | null>;
+    verifyOutputs: (outputs: KanbanArtifactRef[]) => Promise<boolean>;
+};
+declare function dependencyResults(options: KanbanAutomationOptions, boardId: string, item: KanbanItem): Promise<unknown>;
+
+type KanbanControlState = 'accepted' | 'paused' | 'resumed' | 'cancelled' | 'unknown';
+interface KanbanControlRequest {
+    executionId: string;
+    operationId: string;
+    action: 'pause' | 'resume' | 'cancel';
+    attemptId?: string;
+    kind?: 'call' | 'submission';
+    prepared?: unknown;
+    previousKey?: string;
+    fallbackSubmission?: boolean;
+}
+interface KanbanExecutionControlPort {
+    control(request: KanbanControlRequest): Promise<KanbanControlState>;
+    inspect?(executionId: string, attemptId?: string): Promise<{
+        settled: boolean;
+        outcome?: 'succeeded' | 'failed' | 'cancelled';
+    } | undefined>;
+}
+interface KanbanTaskControlOptions {
+    control: KanbanExecutionControlPort;
+    references?: KanbanReferencePolicy;
+    finalizerPrefix?: string;
+}
+
+type TaskControlPorts = KanbanTaskControlOptions;
+/** Controls run even with scheduling disabled and never depend on the business channel. */
+declare function scanTaskControls(options: TaskControlPorts, journal: KanbanAutomationJournal, board: KanbanBoard, service: KanbanService): Promise<void>;
+
+/** Observe accepted analyses to completion, without adopting a new plan or starting another call. */
+declare function drainBoardAnalyses(ports: KanbanTaskControlOptions, journal: KanbanAutomationJournal, board: KanbanBoard, service: KanbanService): Promise<void>;
+
+interface Options$1 {
+    service: KanbanClient;
+    journal: KanbanAutomationJournal;
+    ports: TaskControlPorts;
+    fixes?: {
+        cancelFix(board: string, request: {
+            fixId: string;
+            operationId: string;
+        }): Promise<KanbanFixSession>;
+    };
+    records?: {
+        controlRecord(board: string, request: {
+            recordId: string;
+            operationId: string;
+            action: 'cancel';
+        }): Promise<void>;
+    };
+}
+/** Cancellation is explicit; drain mode only freezes future admissions and retains user settlement choices. */
+declare function scanBoardStopWork(options: Options$1): Promise<void>;
+
+/** Submission claims and definite no-start cancellation compete in the original journal transaction. */
+declare function cancelTaskMaintenance(options: TaskControlPorts, journal: KanbanAutomationJournal, board: string, item: string, controlId: string): Promise<'cancelled' | 'accepted' | 'unknown'>;
+
+/** Freeze out later delivery before reconciling an already admitted reply in its original Session. */
+declare function cancelTaskReplies(options: TaskControlPorts, journal: KanbanAutomationJournal, board: string, item: string, controlId: string): Promise<'cancelled' | 'accepted' | 'unknown'>;
+
+interface Definition {
+    title: string;
+    responsibility: string;
+    acceptance: string;
+    type: string;
+    dependencies: string[];
+}
+interface Snapshot {
+    proposalId: string;
+    messageId: string;
+    content: string;
+    definition: Definition;
+    digest: string;
+    operationId: string;
+}
+interface SavedFix extends KanbanFixSession {
+    phase: 'prepared' | 'submitting' | 'settled';
+    cancelOperationId?: string;
+    dispatch: KanbanDispatch;
+    item: KanbanItem;
+    resourceId: string;
+    context: unknown;
+    request: unknown;
+    snapshot?: Snapshot;
+    code?: string;
+    accepted?: boolean;
+}
+interface KanbanFixOptions<Instruction = unknown> {
+    service: KanbanClient;
+    journal: KanbanAutomationJournal;
+    executor: KanbanExecutionPort;
+    control: KanbanExecutionControlPort;
+    freeze(boardId: string, request: {
+        itemId: string;
+        operationId: string;
+    }): Promise<SavedFix>;
+    confirm(fix: SavedFix, input: Instruction): Promise<boolean>;
+    observe(fix: SavedFix): Promise<void>;
+    accept(fix: SavedFix): Promise<void>;
+    log(event: KanbanRuntimeDiagnostic & {
+        result: 'success' | 'failure';
+    }): void;
+}
+
+interface KanbanTaskFix<Instruction> {
+    fixTask(board: string, request: {
+        itemId: string;
+        operationId: string;
+    }): Promise<KanbanFixSession>;
+    taskFixes(board: string, item: string): Promise<KanbanFixSession[]>;
+    cancelFix(board: string, request: {
+        fixId: string;
+        operationId: string;
+    }): Promise<KanbanFixSession>;
+    intercept(session: string, input: Instruction): Promise<boolean>;
+    scan(): Promise<void>;
+    quiesce(): Promise<void>;
+}
+declare function createTaskFix<Instruction>(options: KanbanFixOptions<Instruction>): KanbanTaskFix<Instruction>;
+
+interface DecisionContext {
+    sourceBoardId: string;
+    recordId: string;
+    recordRevision: number;
+    runId: string;
+}
+/** The host resolves business identity; execution transports receive opaque structured context. */
+declare function workContext(journal: KanbanAutomationJournal, board: KanbanBoard, item: KanbanItem, references?: KanbanReferencePolicy): Promise<{
+    board: {
+        id: string;
+        title: string;
+        revision: number;
+    };
+    decision: {
+        snapshot?: {} | undefined;
+        sourceBoardId: string;
+        recordId: string;
+        recordRevision: number;
+        runId: string;
+    } | null;
+    task: {
+        id: string;
+        revision: number;
+        parentId: string | null;
+        title: string;
+        responsibility: string;
+        acceptance: string;
+        dependencies: string[];
+    };
+    resources: KanbanExternalReference[];
+}>;
+
+interface KanbanTaskReply {
+    itemId: string;
+    attemptId: string;
+    replyTo: string;
+    operationId: string;
+    content: string;
+}
+type FrozenReply<T = unknown> = T & {
+    phase?: 'prepared' | 'submitting' | 'cancelling' | 'cancelled';
+    boardId: string;
+    request: KanbanTaskReply;
+    sessionId: string;
+};
+interface KanbanReplyPort<T> {
+    prepare(input: {
+        boardId: string;
+        request: KanbanTaskReply;
+        item: KanbanItem;
+        dispatch: KanbanDispatch;
+    }): Promise<T & {
+        sessionId: string;
+    }>;
+    deliver(reply: FrozenReply<T>): Promise<void>;
+}
+/** The durable Session queue carries correlated user input without a workspace mailbox. */
+declare function taskReplies<T>(service: KanbanClient, journal: KanbanAutomationJournal, port: KanbanReplyPort<T>): ((boardId: string, request: KanbanTaskReply) => Promise<void>) & {
+    scan(): Promise<void>;
+};
+
+interface KanbanRuntimeContext {
+    fs: IFileSystem;
+    store: KanbanStore;
+    service: KanbanActivityHandle;
+    journal: KanbanAutomationJournal;
+    workLog: KanbanWorkLog;
+    serviceFor(actor: KanbanActor): KanbanActivityHandle;
+}
+/** Extensions bind host facilities; recovery and shutdown are coordinated by the runtime. */
+interface KanbanRuntimeExtension {
+    capabilities?: Partial<KanbanClient>;
+    scan?(): Promise<void>;
+    quiesce?(): Promise<void>;
+    dispose?(): Promise<void>;
+}
+interface KanbanRuntimeOptions extends Omit<KanbanActivityModuleOptions, 'store' | 'referenceSystem'> {
+    fs: IFileSystem;
+    directory?: string;
+    store?: KanbanStore;
+    referenceSystem?: string;
+    journal?: KanbanJournalOptions | KanbanAutomationJournal;
+    workLog?: KanbanWorkLogOptions;
+    resources?: KanbanResourceCatalog;
+    requiresItemResource?: (board: KanbanBoard) => boolean;
+    control?: KanbanTaskControlOptions;
+    automation?: Omit<KanbanAutomationOptions, 'fs' | 'directory' | 'service' | 'serviceFor' | 'journal' | 'workLog' | 'log'>;
+    extensions?(context: KanbanRuntimeContext): KanbanRuntimeExtension[];
+    createService?(options: KanbanActivityModuleOptions): KanbanActivityHandle;
+}
+
+/** One entry point owns durable coordination; the host supplies I/O and authorization. */
+declare function assembleKanbanRuntime(options: KanbanRuntimeOptions): Promise<{
+    service: {
+        scan: () => Promise<void>;
+        quiesce: () => Promise<void>;
+        dispose: () => Promise<void>;
+        records: (board: string, query?: KanbanRecordQuery) => Promise<KanbanRecordPage>;
+        record: (board: string, id: string) => Promise<KanbanProjectRecord>;
+        automationCatalog?: (() => Promise<KanbanAutomationCatalog>) | undefined;
+        analysisStatus?: ((board: string, item: string) => Promise<KanbanAnalysisStatus | null>) | undefined;
+        recordExecutions?: ((board: string, id: string) => Promise<never[] | KanbanRecordExecution[]>) | undefined;
+        itemResources?: ((boardId: string, parentId?: string) => Promise<KanbanItemResourceCatalog>) | undefined;
+        recordResources?: (() => Promise<{
+            reference: KanbanExternalReference;
+            label: string;
+        }[]>) | undefined;
+        runRecord?: ((boardId: string, request: KanbanRecordRunRequest) => Promise<KanbanRecordExecution>) | undefined;
+        controlRecord?: ((boardId: string, request: {
+            recordId: string;
+            operationId: string;
+            action: "pause" | "resume" | "cancel";
+        }) => Promise<void>) | undefined;
+        cancelBoard?: ((boardId: string, request: {
+            operationId: string;
+            expectedRevision: number;
+        }) => Promise<void>) | undefined;
+        requestBoardDeletion?: ((boardId: string, request: KanbanDeletionRequest & {
+            mode: "drain" | "cancel";
+        }) => Promise<void>) | undefined;
+        previewDeletion?: ((boardId: string) => Promise<KanbanDeletionPreview>) | undefined;
+        deleteBoard?: ((boardId: string, request: KanbanDeletionRequest) => Promise<void>) | undefined;
+        itemOperations?: ((boardId: string, itemId: string) => Promise<KanbanItemOperations>) | undefined;
+        runItemOperation?: ((boardId: string, request: KanbanItemOperationRequest) => Promise<KanbanItemOperations>) | undefined;
+        bindItemOperation?: ((boardId: string, request: KanbanItemOperationBinding) => Promise<KanbanItemOperations>) | undefined;
+        workResources?: ((boardId: string, itemId: string, query?: KanbanWorkResourceQuery) => Promise<KanbanWorkResource[]>) | undefined;
+        cleanupWorkResource?: ((boardId: string, request: KanbanWorkResourceCleanup) => Promise<KanbanWorkResource>) | undefined;
+        replyTask?: ((boardId: string, request: {
+            itemId: string;
+            attemptId: string;
+            replyTo: string;
+            operationId: string;
+            content: string;
+        }) => Promise<void>) | undefined;
+        taskFixes?: ((boardId: string, itemId: string) => Promise<KanbanFixSession[]>) | undefined;
+        cancelFix?: ((boardId: string, request: {
+            fixId: string;
+            operationId: string;
+        }) => Promise<KanbanFixSession>) | undefined;
+        fixTask?: ((boardId: string, request: {
+            itemId: string;
+            operationId: string;
+        }) => Promise<KanbanFixSession>) | undefined;
+        queryActivity: (boardId: string, query?: KanbanSessionActivityQuery) => Promise<KanbanSessionItemPage>;
+        executionSession: (boardId: string, itemId: string, query?: KanbanSessionDetailQuery) => Promise<KanbanExecutionSessionDetail>;
+        workflow: (boardId: string) => Promise<KanbanWorkflowState>;
+        resolve: (reference: string) => Promise<KanbanReferenceTarget>;
+        suggest: (boardId: string, query: KanbanSuggestionQuery) => Promise<KanbanSuggestionPage>;
+        currentPrincipal: () => Promise<KanbanPrincipal>;
+        create: (board: KanbanBoardInput) => Promise<KanbanBoard>;
+        read: (boardId: string) => Promise<KanbanBoard>;
+        list: () => Promise<KanbanBoard[]>;
+        catalog: () => Promise<KanbanBoardSummary[]>;
+        execute: (boardId: string, request: KanbanRequest) => Promise<KanbanBoard>;
+        events: (boardId: string, afterSequence?: number, limit?: number) => Promise<KanbanEvent[]>;
+        related: (sessionId: string) => Promise<KanbanBoard[]>;
+        query: (boardId: string, query?: KanbanItemQuery) => Promise<KanbanItemPage>;
+        item: (boardId: string, itemId: string) => Promise<{
+            item: KanbanItem;
+            task?: KanbanTaskProjection;
+            archive?: Omit<KanbanArchivedItem, "item">;
+        }>;
+        overview: (boardId: string) => Promise<KanbanOverview>;
+    } & Pick<{
+        previewDeletion: (id: string) => Promise<KanbanDeletionPreview>;
+        assertSettled: (id: string) => Promise<void>;
+        deleteBoard: (id: string, request: KanbanDeletionRequest) => Promise<void>;
+        cancelBoard: (board: string, request: {
+            operationId: string;
+            expectedRevision: number;
+        }) => Promise<void>;
+        requestBoardDeletion: (board: string, request: KanbanDeletionRequest & {
+            mode: "drain" | "cancel";
+        }) => Promise<void>;
+        preparePending: () => Promise<void>;
+        resumePending: () => Promise<void>;
+    }, "previewDeletion" | "deleteBoard">;
+    fs: _nestos_vfs_core.IFileSystem;
+    store: KanbanStore;
+    journal: KanbanAutomationJournal;
+    workLog: KanbanWorkLog;
+    serviceFor(actor: KanbanActor): KanbanActivityHandle;
+}>;
+
+/** Transport-neutral durable execution data. Requests and results belong to the adapter. */
+interface KanbanOperationRecord {
+    id: string;
+    boardId: string;
+    itemId: string;
+    action: string;
+    fingerprint: string;
+    phase: 'prepared' | 'submitting' | 'settled';
+    state: 'running' | 'unknown' | 'succeeded' | 'failed';
+    createdAt: number;
+    sessionId?: string;
+    code?: string;
+    result?: unknown;
+}
+interface KanbanOperationObservation {
+    state: 'running' | 'unknown' | 'succeeded' | 'failed';
+    executionId?: string;
+    code?: string;
+    output?: unknown;
+}
+/** Only an authoritative no-start receipt permits submitting the frozen request again. */
+interface KanbanOperationFailure {
+    code: string;
+    disposition: 'retry-unstarted' | 'terminal' | 'unknown';
+    result?: unknown;
+}
+interface KanbanOperationPort<T extends KanbanOperationRecord> {
+    start(record: T): Promise<void>;
+    inspect(record: T): Promise<KanbanOperationObservation>;
+    validate?(record: T, output: unknown): Promise<void> | void;
+    classify?(error: unknown): KanbanOperationFailure;
+    report?(record: T): Promise<void>;
+}
+
+interface Options<T extends KanbanOperationRecord> {
+    service: Pick<KanbanClient, 'read'>;
+    journal: KanbanAutomationJournal;
+    key: string;
+    record: T;
+    port: KanbanOperationPort<T>;
+}
+/** A frozen record crosses the submission boundary once; response loss only triggers inspection. */
+declare function coordinateOperation<T extends KanbanOperationRecord>(options: Options<T>): Promise<T>;
+
+interface KanbanFixPreparation {
+    resourceId: string;
+    context: unknown;
+}
+declare class KanbanCollaboration {
+    private readonly service;
+    private readonly journal;
+    constructor(service: KanbanClient, journal: KanbanAutomationJournal);
+    prepareFix(boardId: string, request: {
+        itemId: string;
+        operationId: string;
+    }, prepare: (input: {
+        id: string;
+        board: KanbanBoard;
+        item: KanbanItem;
+    }) => Promise<KanbanFixPreparation>): Promise<SavedFix>;
+    fix(id: string): Promise<SavedFix>;
+    confirmFix(id: string, snapshot: Snapshot): Promise<SavedFix>;
+    acceptFix(id: string, policy: {
+        kind: string;
+        inheritSystems: string[];
+    }, deliver: (fix: SavedFix) => Promise<void>): Promise<void>;
+    private publishFix;
+    decisionSnapshot(identity: {
+        sourceBoardId: string;
+        recordId: string;
+        recordRevision: number;
+        runId: string;
+    }): Promise<KanbanProjectRecord>;
+}
+/** Adapter requests remain opaque; relation projection does not expose journal layouts. */
+declare function collaborationRelations<Input = unknown>(journal: KanbanAutomationJournal, boardId: string, itemId: string): Promise<{
+    planning: {
+        id: string;
+        request: Input;
+    }[];
+    replies: {
+        operationId: string;
+        executionId: string;
+    }[];
+}>;
+
+export { type AnalysisJournalEntry, type AnalysisResult, type AnalysisSubtask, type DecisionContext, type Definition, type FrozenReply, type KanbanAnalysisObservation, type KanbanAnalysisOptions, type KanbanAnalysisPort, KanbanAutomationJournal, type KanbanAutomationOptions, KanbanCollaboration, type KanbanControlRequest, type KanbanControlState, type KanbanExecutionControlPort, type KanbanExecutorContext, type KanbanFixOptions, type KanbanFixPreparation, KanbanJournalOptions, type KanbanOperationFailure, type KanbanOperationObservation, type KanbanOperationPort, type KanbanOperationRecord, KanbanReferencePolicy, type KanbanReplyPort, KanbanResourceCatalog, type KanbanRuntimeContext, KanbanRuntimeDiagnostic, type KanbanRuntimeExtension, type KanbanRuntimeOptions, type KanbanTaskControlOptions, type KanbanTaskFix, type KanbanTaskReply, KanbanWorkLog, KanbanWorkLogOptions, type RecordControl, type SavedFix, type Snapshot, type TaskControlPorts, type WorkLogFact, adoptDecomposition, advanceRecordControl, analysisHistory, analysisSignature, analysisStatus, analyzeItem, assembleKanbanRuntime, boardDeletionBlockers, cancelTaskMaintenance, cancelTaskReplies, collaborationRelations, completeCompositePlans, coordinateOperation, createBoardDeletion, createKanbanAutomation, createRecordExecution, createTaskFix, deletionPreview, dependencyResults, drainBoardAnalyses, journalCommand, parseAnalysis, recordControlKey, requestRecordControl, safeCode, scanBoardStopWork, scanTaskControls, taskReplies, validateResourceReferences, validateSubtasks, withBoardDeletion, workContext };