cogmem 3.6.2

package/dist/binding/MemoryBindingTypes.d.ts

@@ -0,0 +1,140 @@
+export type MemoryEntityType = 'person' | 'project' | 'object' | 'event' | 'time' | 'place' | 'concept';
+export type MemoryBindingType = 'about' | 'mentions' | 'decision' | 'correction' | 'preference' | 'boundary' | 'diagnostic' | 'goal';
+export type MemoryBindingSource = 'deterministic';
+export type MemoryBindingAction = 'create_new_cluster' | 'attach_to_existing' | 'strengthen_existing' | 'possible_conflict' | 'corrects_prior_memory' | 'refines_prior_memory' | 'needs_review';
+export type MemoryClusterStatus = 'active' | 'possible_conflict' | 'superseded';
+export type MemoryEdgeRelation = 'ABOUT' | 'MENTIONS' | 'SUPPORTS' | 'BELONGS_TO' | 'SAME_TOPIC_AS' | 'CORRECTS' | 'CONTRADICTS' | 'REFINES' | 'SUPERSEDES';
+export interface MemoryEntityRecord {
+    entityId: string;
+    projectId?: string;
+    canonicalName: string;
+    entityType: MemoryEntityType;
+    aliases: string[];
+    stablePath?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface MemoryTopicRecord {
+    topicPath: string;
+    projectId?: string;
+    parentPath?: string;
+    topicType: 'project' | 'person' | 'object' | 'event' | 'place' | 'time' | 'concept';
+    summary?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface MemoryBindingRecord {
+    bindingId: string;
+    eventId: string;
+    projectId?: string;
+    role?: string;
+    rawEventType?: string;
+    entityId?: string;
+    entityName?: string;
+    entityType?: MemoryEntityType;
+    topicPath: string;
+    bindingType: MemoryBindingType;
+    confidence: number;
+    source: MemoryBindingSource;
+    signal: string;
+    claimKey: string;
+    bindingAction: MemoryBindingAction;
+    clusterId?: string;
+    relatedEventIds: string[];
+    createdAt: number;
+}
+export interface MemoryBindingInput {
+    eventId: string;
+    projectId?: string;
+    role?: string;
+    rawEventType?: string;
+    entityId?: string;
+    entityName?: string;
+    entityType?: MemoryEntityType;
+    topicPath: string;
+    bindingType: MemoryBindingType;
+    confidence: number;
+    source: MemoryBindingSource;
+    signal: string;
+    claimKey: string;
+    bindingAction?: MemoryBindingAction;
+    clusterId?: string;
+    relatedEventIds?: string[];
+    createdAt?: number;
+}
+export interface MemoryBindingListOptions {
+    projectId?: string;
+    eventId?: string;
+    topicPath?: string;
+    entityName?: string;
+    bindingType?: MemoryBindingType;
+    role?: string;
+    limit?: number;
+}
+export interface MemoryClusterRecord {
+    clusterId: string;
+    projectId?: string;
+    topicPath: string;
+    clusterType: MemoryBindingType | 'topic';
+    title: string;
+    summary: string;
+    claimKey: string;
+    status: MemoryClusterStatus;
+    reviewFlags: string[];
+    confidence: number;
+    supportCount: number;
+    evidenceEventIds: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface MemoryClusterListOptions {
+    projectId?: string;
+    topicPath?: string;
+    clusterType?: MemoryClusterRecord['clusterType'];
+    status?: MemoryClusterStatus;
+    limit?: number;
+}
+export interface MemoryEdgeRecord {
+    edgeId: string;
+    projectId?: string;
+    sourceType: 'event' | 'entity' | 'topic' | 'cluster';
+    sourceId: string;
+    relationType: MemoryEdgeRelation;
+    targetType: 'event' | 'entity' | 'topic' | 'cluster';
+    targetId: string;
+    confidence: number;
+    baseWeight: number;
+    stability: number;
+    activation: number;
+    evidenceEventIds: string[];
+    status: 'active' | 'weak' | 'rejected' | 'superseded';
+    createdAt: number;
+    updatedAt: number;
+    validFrom: number;
+    validTo?: number;
+    version: number;
+    sourceAuthority: 'raw_evidence' | 'governed_projection' | 'model_candidate';
+}
+export interface MemoryEdgeListOptions {
+    projectId?: string;
+    sourceId?: string;
+    targetId?: string;
+    relationType?: MemoryEdgeRelation;
+    limit?: number;
+}
+export interface MemoryGraphRecallAnchor {
+    eventId: string;
+    projectId?: string;
+    topicPath: string;
+    clusterId?: string;
+    confidence: number;
+    whyMatched: 'memory_binding_graph';
+}
+export interface MemoryBindingStats {
+    bindings: number;
+    topics: number;
+    entities: number;
+    clusters: number;
+    edges: number;
+}
+//# sourceMappingURL=MemoryBindingTypes.d.ts.map

package/dist/binding/MemoryBindingTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/binding/TopicPathRegistry.d.ts

@@ -0,0 +1,5 @@
+export declare class TopicPathRegistry {
+    resolveProjectPath(projectName: string, candidate: string): string;
+    canonicalSegment(candidate: string): string;
+}
+//# sourceMappingURL=TopicPathRegistry.d.ts.map

package/dist/binding/TopicPathRegistry.js

@@ -0,0 +1,33 @@
+const SEGMENT_ALIASES = [
+    { canonical: 'memory-write-pipeline', aliases: ['memory storage', 'memory write', 'memory pipeline', '记忆写入', '记忆存储', '写入管线'] },
+    { canonical: 'recall-context-hygiene', aliases: ['context hygiene', 'recall context', '上下文卫生', '记忆注入边界'] },
+    { canonical: 'integration', aliases: ['integration', '集成', '接入'] },
+    { canonical: 'architecture', aliases: ['architecture', 'design', '架构', '设计'] },
+    { canonical: 'release-operations', aliases: ['release', 'deploy', '发布', '部署'] },
+    { canonical: 'timeline', aliases: ['timeline', 'milestone', '时间线', '里程碑'] },
+    { canonical: 'known-risks', aliases: ['risk', 'diagnostic', 'bug', '问题', '风险'] },
+];
+export class TopicPathRegistry {
+    resolveProjectPath(projectName, candidate) {
+        const normalizedCandidate = normalizeLookup(candidate);
+        const known = SEGMENT_ALIASES.find((entry) => (entry.canonical === normalizedCandidate
+            || entry.aliases.some((alias) => normalizeLookup(alias) === normalizedCandidate)));
+        const project = safeSegment(projectName, 'unknown-project');
+        const segment = known?.canonical || safeSegment(candidate, 'general');
+        return `PROJECT/${project}/${segment}`;
+    }
+    canonicalSegment(candidate) {
+        return this.resolveProjectPath('project', candidate).split('/').at(-1) || 'general';
+    }
+}
+function normalizeLookup(value) {
+    return String(value || '').trim().toLowerCase().replace(/[_-]+/g, ' ').replace(/\s+/g, ' ');
+}
+function safeSegment(value, fallback) {
+    const normalized = String(value || '')
+        .normalize('NFKC')
+        .replace(/[^\p{L}\p{N}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-+/g, '-');
+    return normalized || fallback;
+}

package/dist/binding/index.d.ts

@@ -0,0 +1,12 @@
+export { BindingClassifier, normalizeForBinding } from './BindingClassifier.js';
+export type { BindingTopicDecision } from './BindingClassifier.js';
+export { BindingDecisionEngine } from './BindingDecisionEngine.js';
+export type { BindingDecisionInput } from './BindingDecisionEngine.js';
+export { ClaimKeyGenerator } from './ClaimKeyGenerator.js';
+export { TopicPathRegistry } from './TopicPathRegistry.js';
+export { BrainGraphView } from '../graph/BrainGraphView.js';
+export type { BrainGraphTraversalOptions, BrainGraphTraversalResult } from '../graph/BrainGraphView.js';
+export { MemoryBindingService } from './MemoryBindingService.js';
+export type { MemoryBindingEventInput } from './MemoryBindingService.js';
+export type { MemoryBindingInput, MemoryBindingListOptions, MemoryBindingRecord, MemoryBindingSource, MemoryBindingStats, MemoryBindingType, MemoryBindingAction, MemoryClusterListOptions, MemoryClusterRecord, MemoryClusterStatus, MemoryEdgeListOptions, MemoryEdgeRecord, MemoryEdgeRelation, MemoryEntityRecord, MemoryEntityType, MemoryGraphRecallAnchor, MemoryTopicRecord, } from './MemoryBindingTypes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/binding/index.js

@@ -0,0 +1,6 @@
+export { BindingClassifier, normalizeForBinding } from './BindingClassifier.js';
+export { BindingDecisionEngine } from './BindingDecisionEngine.js';
+export { ClaimKeyGenerator } from './ClaimKeyGenerator.js';
+export { TopicPathRegistry } from './TopicPathRegistry.js';
+export { BrainGraphView } from '../graph/BrainGraphView.js';
+export { MemoryBindingService } from './MemoryBindingService.js';

package/dist/boards/ApprovalBoard.d.ts

@@ -0,0 +1,14 @@
+import type { QueryManagerLike } from '../types/ExtensionPoints.js';
+import type { Board, BoardEvent, BoardSnapshot, BoardSnapshotOptions } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class ApprovalBoard implements Board {
+    private readonly approvalManager;
+    private readonly taskManager;
+    readonly id = "approval";
+    readonly description = "Aggregated read-only view of pending approvals and tasks";
+    readonly eventBus: BoardEventBus;
+    constructor(approvalManager: QueryManagerLike, taskManager: QueryManagerLike, eventBus?: BoardEventBus);
+    snapshot(_options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=ApprovalBoard.d.ts.map

package/dist/boards/ApprovalBoard.js

@@ -0,0 +1,32 @@
+import { BoardEventBus } from './BoardEventBus.js';
+export class ApprovalBoard {
+    approvalManager;
+    taskManager;
+    id = 'approval';
+    description = 'Aggregated read-only view of pending approvals and tasks';
+    eventBus;
+    constructor(approvalManager, taskManager, eventBus) {
+        this.approvalManager = approvalManager;
+        this.taskManager = taskManager;
+        this.eventBus = eventBus ?? new BoardEventBus();
+    }
+    async snapshot(_options) {
+        const pendingApprovals = await this.approvalManager.query({ type: 'list_pending' });
+        const tasks = await this.taskManager.query({ type: 'list' });
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data: {
+                pendingApprovals,
+                tasks,
+                summary: {
+                    pendingCount: pendingApprovals.length,
+                    taskCount: tasks.length
+                }
+            }
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribe({ boardId: this.id }, callback);
+    }
+}

package/dist/boards/Board.d.ts

@@ -0,0 +1,23 @@
+export interface BoardSnapshotOptions {
+    limit?: number;
+    since?: number;
+}
+export interface BoardSnapshot {
+    boardId: string;
+    capturedAt: number;
+    data: Record<string, unknown>;
+}
+export interface BoardEvent {
+    boardId: string;
+    eventType: 'task_created' | 'task_updated' | 'memory_ingested' | 'approval_pending' | 'approval_resolved' | 'process_started' | 'process_finished' | 'context_updated' | 'workspace_switched' | 'proposal.created' | 'proposal.eval_started' | 'proposal.eval_result' | 'proposal.approved' | 'proposal.applied' | 'proposal.rolled_back' | 'llm_iteration.started' | 'llm_iteration.tool_called' | 'llm_iteration.policy_rejected' | 'llm_iteration.policy_rewritten' | 'llm_iteration.budget_compressed' | 'llm_iteration.completed' | 'recall_gate.skip' | 'recall_gate.escalation' | 'autonomy.action_approved' | 'autonomy.action_rejected' | 'autonomy.batch_collected' | 'autonomy.budget_exhausted';
+    payload: unknown;
+    timestamp: number;
+    workspaceId?: string;
+}
+export interface Board {
+    readonly id: string;
+    readonly description: string;
+    snapshot(options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=Board.d.ts.map

package/dist/boards/Board.js

@@ -0,0 +1 @@
+export {};

package/dist/boards/BoardEventBuffer.d.ts

@@ -0,0 +1,10 @@
+import type { BoardEvent } from './Board.js';
+export declare class BoardEventBuffer {
+    private readonly maxSize;
+    private readonly events;
+    constructor(maxSize?: number);
+    push(event: BoardEvent): void;
+    getRecent(limit?: number): BoardEvent[];
+    size(): number;
+}
+//# sourceMappingURL=BoardEventBuffer.d.ts.map

package/dist/boards/BoardEventBuffer.js

@@ -0,0 +1,22 @@
+export class BoardEventBuffer {
+    maxSize;
+    events = [];
+    constructor(maxSize = 500) {
+        this.maxSize = maxSize;
+    }
+    push(event) {
+        this.events.push(event);
+        if (this.events.length > this.maxSize) {
+            this.events.shift();
+        }
+    }
+    getRecent(limit = this.maxSize) {
+        if (limit <= 0) {
+            return [];
+        }
+        return this.events.slice(-Math.min(limit, this.events.length));
+    }
+    size() {
+        return this.events.length;
+    }
+}

package/dist/boards/BoardEventBus.d.ts

@@ -0,0 +1,15 @@
+import type { BoardEvent } from './Board.js';
+import type { BoardEventFilter } from './BoardEventFilter.js';
+/**
+ * @public experimental
+ */
+export declare class BoardEventBus {
+    private readonly emitter;
+    private readonly buffer;
+    constructor(maxSize?: number);
+    emit(event: BoardEvent): void;
+    subscribe(filter: BoardEventFilter, callback: (event: BoardEvent) => void): () => void;
+    subscribeAll(callback: (event: BoardEvent) => void): () => void;
+    getRecentEvents(limit?: number): BoardEvent[];
+}
+//# sourceMappingURL=BoardEventBus.d.ts.map

package/dist/boards/BoardEventBus.js

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'node:events';
+import { BoardEventBuffer } from './BoardEventBuffer.js';
+const BOARD_EVENT_NAME = 'board:event';
+/**
+ * @public experimental
+ */
+export class BoardEventBus {
+    emitter = new EventEmitter();
+    buffer;
+    constructor(maxSize = 500) {
+        this.buffer = new BoardEventBuffer(maxSize);
+    }
+    emit(event) {
+        this.buffer.push(event);
+        this.emitter.emit(BOARD_EVENT_NAME, event);
+    }
+    subscribe(filter, callback) {
+        const listener = (event) => {
+            if (filter.boardId && filter.boardId !== event.boardId) {
+                return;
+            }
+            if (filter.eventType && filter.eventType !== event.eventType) {
+                return;
+            }
+            callback(event);
+        };
+        this.emitter.on(BOARD_EVENT_NAME, listener);
+        return () => {
+            this.emitter.off(BOARD_EVENT_NAME, listener);
+        };
+    }
+    subscribeAll(callback) {
+        return this.subscribe({}, callback);
+    }
+    getRecentEvents(limit = 500) {
+        return this.buffer.getRecent(limit);
+    }
+}

package/dist/boards/BoardEventFilter.d.ts

@@ -0,0 +1,5 @@
+export interface BoardEventFilter {
+    boardId?: string;
+    eventType?: string;
+}
+//# sourceMappingURL=BoardEventFilter.d.ts.map

package/dist/boards/BoardEventFilter.js

@@ -0,0 +1 @@
+export {};

package/dist/boards/BoardRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { Board } from './Board.js';
+/**
+ * @public stable
+ */
+export declare class BoardRegistry {
+    private boards;
+    register(board: Board): void;
+    get(id: string): Board | undefined;
+    list(): Board[];
+}
+//# sourceMappingURL=BoardRegistry.d.ts.map

package/dist/boards/BoardRegistry.js

@@ -0,0 +1,15 @@
+/**
+ * @public stable
+ */
+export class BoardRegistry {
+    boards = new Map();
+    register(board) {
+        this.boards.set(board.id, board);
+    }
+    get(id) {
+        return this.boards.get(id);
+    }
+    list() {
+        return [...this.boards.values()];
+    }
+}

package/dist/boards/ContextBoard.d.ts

@@ -0,0 +1,15 @@
+import type { QueryManagerLike } from '../types/ExtensionPoints.js';
+import type { Board, BoardEvent, BoardSnapshot, BoardSnapshotOptions } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class ContextBoard implements Board {
+    private readonly contextManager;
+    private readonly traceManager;
+    private readonly taskId;
+    readonly id = "context";
+    readonly description = "Aggregated read-only view of context summary and recent traces";
+    readonly eventBus: BoardEventBus;
+    constructor(contextManager: QueryManagerLike, traceManager: QueryManagerLike, taskId: string, eventBus?: BoardEventBus);
+    snapshot(_options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=ContextBoard.d.ts.map

package/dist/boards/ContextBoard.js

@@ -0,0 +1,33 @@
+import { BoardEventBus } from './BoardEventBus.js';
+export class ContextBoard {
+    contextManager;
+    traceManager;
+    taskId;
+    id = 'context';
+    description = 'Aggregated read-only view of context summary and recent traces';
+    eventBus;
+    constructor(contextManager, traceManager, taskId, eventBus) {
+        this.contextManager = contextManager;
+        this.traceManager = traceManager;
+        this.taskId = taskId;
+        this.eventBus = eventBus ?? new BoardEventBus();
+    }
+    async snapshot(_options) {
+        const contextSummary = await this.contextManager.query({ type: 'current_pack', taskId: this.taskId });
+        const recentTraces = await this.traceManager.query({ type: 'recent', limit: 5 });
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data: {
+                contextSummary,
+                recentTraces,
+                summary: {
+                    traceCount: recentTraces.length
+                }
+            }
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribe({ boardId: this.id }, callback);
+    }
+}

package/dist/boards/MemoryBoard.d.ts

@@ -0,0 +1,13 @@
+import type { QueryManagerLike } from '../types/ExtensionPoints.js';
+import type { Board, BoardEvent, BoardSnapshot, BoardSnapshotOptions } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class MemoryBoard implements Board {
+    private readonly memoryManager;
+    readonly id = "memory";
+    readonly description = "Aggregated read-only view of recent memory facts";
+    readonly eventBus: BoardEventBus;
+    constructor(memoryManager: QueryManagerLike, eventBus?: BoardEventBus);
+    snapshot(options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=MemoryBoard.d.ts.map

package/dist/boards/MemoryBoard.js

@@ -0,0 +1,30 @@
+import { BoardEventBus } from './BoardEventBus.js';
+export class MemoryBoard {
+    memoryManager;
+    id = 'memory';
+    description = 'Aggregated read-only view of recent memory facts';
+    eventBus;
+    constructor(memoryManager, eventBus) {
+        this.memoryManager = memoryManager;
+        this.eventBus = eventBus ?? new BoardEventBus();
+    }
+    async snapshot(options) {
+        const recentFacts = await this.memoryManager.query({
+            type: 'recent_facts',
+            limit: options?.limit ?? 10
+        });
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data: {
+                recentFacts,
+                summary: {
+                    factCount: recentFacts.length
+                }
+            }
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribe({ boardId: this.id }, callback);
+    }
+}

package/dist/boards/ProcessBoard.d.ts

@@ -0,0 +1,16 @@
+import type { QueryManagerLike, RuntimeSelfManifestLike } from '../types/ExtensionPoints.js';
+import type { Board, BoardEvent, BoardSnapshot, BoardSnapshotOptions } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class ProcessBoard implements Board {
+    private readonly capabilityManager;
+    private readonly traceManager;
+    private readonly getRuntimeSelfManifest?;
+    readonly id = "process";
+    readonly description = "Aggregated read-only view of capabilities and recent traces";
+    readonly eventBus: BoardEventBus;
+    constructor(capabilityManager: QueryManagerLike, traceManager: QueryManagerLike, eventBus?: BoardEventBus, getRuntimeSelfManifest?: (() => RuntimeSelfManifestLike | null) | undefined);
+    snapshot(options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+    private summarizeRuntimeSelf;
+}
+//# sourceMappingURL=ProcessBoard.d.ts.map

package/dist/boards/ProcessBoard.js

@@ -0,0 +1,56 @@
+import { BoardEventBus } from './BoardEventBus.js';
+export class ProcessBoard {
+    capabilityManager;
+    traceManager;
+    getRuntimeSelfManifest;
+    id = 'process';
+    description = 'Aggregated read-only view of capabilities and recent traces';
+    eventBus;
+    constructor(capabilityManager, traceManager, eventBus, getRuntimeSelfManifest) {
+        this.capabilityManager = capabilityManager;
+        this.traceManager = traceManager;
+        this.getRuntimeSelfManifest = getRuntimeSelfManifest;
+        this.eventBus = eventBus ?? new BoardEventBus();
+    }
+    async snapshot(options) {
+        const capabilities = await this.capabilityManager.query({ type: 'list' });
+        const recentTraces = await this.traceManager.query({
+            type: 'recent',
+            limit: options?.limit ?? 10
+        });
+        const data = {
+            capabilities,
+            recentTraces,
+            summary: {
+                capabilityCount: capabilities.length,
+                traceCount: recentTraces.length,
+                runtimeSelfManifestId: this.getRuntimeSelfManifest?.()?.manifestId
+            }
+        };
+        const runtimeSelf = this.summarizeRuntimeSelf();
+        if (runtimeSelf) {
+            data.runtimeSelf = runtimeSelf;
+        }
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribe({ boardId: this.id }, callback);
+    }
+    summarizeRuntimeSelf() {
+        const manifest = this.getRuntimeSelfManifest?.();
+        if (!manifest)
+            return null;
+        return {
+            manifestId: manifest.manifestId,
+            generatedAt: manifest.generatedAt,
+            capabilityCount: manifest.capabilities.length,
+            modelCount: manifest.models.roles.length,
+            fileAssetCount: manifest.fileAssets.indexedAssetCount,
+            constraints: manifest.constraints.map((constraint) => constraint.id)
+        };
+    }
+}

package/dist/boards/ProposalBoard.d.ts

@@ -0,0 +1,13 @@
+import type { ProposalLedger } from '../meta/ProposalLedger.js';
+import type { Board, BoardEvent, BoardSnapshot, BoardSnapshotOptions } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class ProposalBoard implements Board {
+    private readonly ledger;
+    readonly id = "proposals";
+    readonly description = "Read-only view of proposal lifecycle and status";
+    readonly eventBus: BoardEventBus;
+    constructor(ledger: ProposalLedger, eventBus?: BoardEventBus);
+    snapshot(_options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=ProposalBoard.d.ts.map

package/dist/boards/ProposalBoard.js

@@ -0,0 +1,37 @@
+import { BoardEventBus } from './BoardEventBus.js';
+const PROPOSAL_STATUSES = [
+    'pending',
+    'under_eval',
+    'passed_eval',
+    'failed_eval',
+    'approved',
+    'applied',
+    'rolled_back',
+    'rejected'
+];
+export class ProposalBoard {
+    ledger;
+    id = 'proposals';
+    description = 'Read-only view of proposal lifecycle and status';
+    eventBus;
+    constructor(ledger, eventBus) {
+        this.ledger = ledger;
+        this.eventBus = eventBus ?? new BoardEventBus();
+    }
+    async snapshot(_options) {
+        const all = this.ledger.list();
+        const byStatus = Object.fromEntries(PROPOSAL_STATUSES.map((status) => [status, all.filter((proposal) => proposal.status === status).length]));
+        return {
+            boardId: this.id,
+            capturedAt: Date.now(),
+            data: {
+                totalProposals: all.length,
+                byStatus,
+                recent: all.slice(0, 10)
+            }
+        };
+    }
+    stream(callback) {
+        return this.eventBus.subscribe({ boardId: this.id }, callback);
+    }
+}

package/dist/boards/ReasoningTraceBoard.d.ts

@@ -0,0 +1,11 @@
+import type { Board, BoardSnapshot, BoardSnapshotOptions, BoardEvent } from './Board.js';
+import { BoardEventBus } from './BoardEventBus.js';
+export declare class ReasoningTraceBoard implements Board {
+    private readonly eventBus;
+    readonly id = "reasoning_trace";
+    readonly description = "LLM iterative reasoning and tool call trace";
+    constructor(eventBus?: BoardEventBus);
+    snapshot(options?: BoardSnapshotOptions): Promise<BoardSnapshot>;
+    stream(callback: (event: BoardEvent) => void): () => void;
+}
+//# sourceMappingURL=ReasoningTraceBoard.d.ts.map