nodebench-mcp 2.69.0 → 3.0.0

package/dist/sync/sessionMemory.d.ts

@@ -0,0 +1,47 @@
+/**
+ * sessionMemory.ts — Session-scoped action/failure memory for agent learning.
+ *
+ * Ported from TA Studio's SessionMemory + LearningStore pattern.
+ * Records every action and failure in a session, generates reflection
+ * prompts for retry, and persists recovery strategies across sessions.
+ *
+ * Storage: SQLite (shared with founderEpisodeStore).
+ */
+export interface ActionRecord {
+    actionId: string;
+    episodeId: string;
+    stepIndex: number;
+    toolName: string;
+    input: string;
+    output: string;
+    success: boolean;
+    durationMs: number;
+    timestamp: string;
+}
+export interface FailureRecord {
+    failureId: string;
+    episodeId: string;
+    stepIndex: number;
+    toolName: string;
+    failureType: string;
+    rootCause: string;
+    recoveryStrategy: string;
+    recoverySuccessful: boolean | null;
+    timestamp: string;
+}
+export interface RecoveryStrategy {
+    strategyId: string;
+    failureType: string;
+    toolName: string;
+    strategy: string;
+    successCount: number;
+    failureCount: number;
+    lastUsed: string;
+}
+export declare function initSessionMemoryTables(): void;
+export declare function recordAction(action: Omit<ActionRecord, "actionId">): ActionRecord;
+export declare function recordFailure(failure: Omit<FailureRecord, "failureId">): FailureRecord;
+export declare function recordRecoveryOutcome(failureType: string, toolName: string, strategy: string, succeeded: boolean): void;
+export declare function getReflectionPrompt(failureType: string, toolName: string): string;
+export declare function getSessionActions(episodeId: string): ActionRecord[];
+export declare function getSessionFailures(episodeId: string): FailureRecord[];

package/dist/sync/sessionMemory.js

@@ -0,0 +1,138 @@
+/**
+ * sessionMemory.ts — Session-scoped action/failure memory for agent learning.
+ *
+ * Ported from TA Studio's SessionMemory + LearningStore pattern.
+ * Records every action and failure in a session, generates reflection
+ * prompts for retry, and persists recovery strategies across sessions.
+ *
+ * Storage: SQLite (shared with founderEpisodeStore).
+ */
+import { getDb, genId } from "../db.js";
+// ─── Schema init ─────────────────────────────────────────────────
+const MAX_ACTIONS_PER_EPISODE = 200;
+const MAX_RECOVERY_STRATEGIES = 100;
+const TRUNCATE_LIMIT = 2048;
+function truncate(s, limit = TRUNCATE_LIMIT) {
+    return s.length > limit ? s.slice(0, limit - 3) + "..." : s;
+}
+export function initSessionMemoryTables() {
+    const db = getDb();
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS session_actions (
+      action_id TEXT PRIMARY KEY,
+      episode_id TEXT NOT NULL,
+      step_index INTEGER NOT NULL,
+      tool_name TEXT NOT NULL,
+      input TEXT NOT NULL,
+      output TEXT NOT NULL,
+      success INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      timestamp TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS session_failures (
+      failure_id TEXT PRIMARY KEY,
+      episode_id TEXT NOT NULL,
+      step_index INTEGER NOT NULL,
+      tool_name TEXT NOT NULL,
+      failure_type TEXT NOT NULL,
+      root_cause TEXT NOT NULL,
+      recovery_strategy TEXT NOT NULL,
+      recovery_successful INTEGER,
+      timestamp TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS recovery_strategies (
+      strategy_id TEXT PRIMARY KEY,
+      failure_type TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      strategy TEXT NOT NULL,
+      success_count INTEGER NOT NULL DEFAULT 0,
+      failure_count INTEGER NOT NULL DEFAULT 0,
+      last_used TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_actions_episode ON session_actions(episode_id);
+    CREATE INDEX IF NOT EXISTS idx_failures_episode ON session_failures(episode_id);
+    CREATE INDEX IF NOT EXISTS idx_recovery_type ON recovery_strategies(failure_type, tool_name);
+  `);
+}
+// ─── Record actions ──────────────────────────────────────────────
+export function recordAction(action) {
+    const db = getDb();
+    initSessionMemoryTables();
+    const actionId = genId("action");
+    // Enforce bounded memory: evict oldest actions if over limit
+    const countStmt = db.prepare("SELECT COUNT(*) as cnt FROM session_actions WHERE episode_id = ?");
+    const count = countStmt.get(action.episodeId)?.cnt ?? 0;
+    if (count >= MAX_ACTIONS_PER_EPISODE) {
+        db.prepare("DELETE FROM session_actions WHERE action_id IN (SELECT action_id FROM session_actions WHERE episode_id = ? ORDER BY timestamp ASC LIMIT 10)").run(action.episodeId);
+    }
+    db.prepare(`
+    INSERT INTO session_actions (action_id, episode_id, step_index, tool_name, input, output, success, duration_ms, timestamp)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(actionId, action.episodeId, action.stepIndex, action.toolName, truncate(action.input), truncate(action.output), action.success ? 1 : 0, action.durationMs, action.timestamp);
+    return { ...action, actionId };
+}
+// ─── Record failures ─────────────────────────────────────────────
+export function recordFailure(failure) {
+    const db = getDb();
+    initSessionMemoryTables();
+    const failureId = genId("failure");
+    db.prepare(`
+    INSERT INTO session_failures (failure_id, episode_id, step_index, tool_name, failure_type, root_cause, recovery_strategy, recovery_successful, timestamp)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(failureId, failure.episodeId, failure.stepIndex, failure.toolName, failure.failureType, failure.rootCause, failure.recoveryStrategy, failure.recoverySuccessful == null ? null : failure.recoverySuccessful ? 1 : 0, failure.timestamp);
+    return { ...failure, failureId };
+}
+// ─── Recovery strategy persistence ───────────────────────────────
+export function recordRecoveryOutcome(failureType, toolName, strategy, succeeded) {
+    const db = getDb();
+    initSessionMemoryTables();
+    const existing = db.prepare("SELECT strategy_id, success_count, failure_count FROM recovery_strategies WHERE failure_type = ? AND tool_name = ? AND strategy = ?").get(failureType, toolName, strategy);
+    if (existing) {
+        if (succeeded) {
+            db.prepare("UPDATE recovery_strategies SET success_count = success_count + 1, last_used = ? WHERE strategy_id = ?")
+                .run(new Date().toISOString(), existing.strategy_id);
+        }
+        else {
+            db.prepare("UPDATE recovery_strategies SET failure_count = failure_count + 1, last_used = ? WHERE strategy_id = ?")
+                .run(new Date().toISOString(), existing.strategy_id);
+        }
+    }
+    else {
+        // Enforce bounded: evict lowest success rate if over limit
+        const countRow = db.prepare("SELECT COUNT(*) as cnt FROM recovery_strategies").get();
+        if ((countRow?.cnt ?? 0) >= MAX_RECOVERY_STRATEGIES) {
+            db.prepare("DELETE FROM recovery_strategies WHERE strategy_id IN (SELECT strategy_id FROM recovery_strategies ORDER BY (CAST(success_count AS REAL) / MAX(success_count + failure_count, 1)) ASC LIMIT 5)").run();
+        }
+        db.prepare(`
+      INSERT INTO recovery_strategies (strategy_id, failure_type, tool_name, strategy, success_count, failure_count, last_used)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(genId("recovery"), failureType, toolName, strategy, succeeded ? 1 : 0, succeeded ? 0 : 1, new Date().toISOString());
+    }
+}
+// ─── Reflection prompt generation ────────────────────────────────
+export function getReflectionPrompt(failureType, toolName) {
+    const db = getDb();
+    initSessionMemoryTables();
+    // Get proven recovery strategies for this failure type
+    const strategies = db.prepare("SELECT strategy, success_count, failure_count FROM recovery_strategies WHERE failure_type = ? AND tool_name = ? AND success_count > 0 ORDER BY success_count DESC LIMIT 3").all(failureType, toolName);
+    if (strategies.length === 0) {
+        return `No known recovery strategies for ${failureType} on ${toolName}. Try a different approach.`;
+    }
+    const lines = strategies.map((s, i) => `${i + 1}. "${s.strategy}" (succeeded ${s.success_count}x, failed ${s.failure_count}x)`);
+    return `Known recovery strategies for ${failureType} on ${toolName}:\n${lines.join("\n")}\nUse the most successful strategy, or try a new approach if all have been exhausted.`;
+}
+// ─── Query helpers ────────────────────────────────────────────────
+export function getSessionActions(episodeId) {
+    const db = getDb();
+    initSessionMemoryTables();
+    return db.prepare("SELECT * FROM session_actions WHERE episode_id = ? ORDER BY step_index ASC").all(episodeId);
+}
+export function getSessionFailures(episodeId) {
+    const db = getDb();
+    initSessionMemoryTables();
+    return db.prepare("SELECT * FROM session_failures WHERE episode_id = ? ORDER BY step_index ASC").all(episodeId);
+}
+//# sourceMappingURL=sessionMemory.js.map

package/dist/sync/sessionMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionMemory.js","sourceRoot":"","sources":["../../src/sync/sessionMemory.ts"],"names":[],"mappings":"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"}

package/dist/sync/store.d.ts

@@ -0,0 +1,384 @@
+import { EventEmitter } from "node:events";
+import type { DurableObjectKind, SharedContextMessageClass, SharedContextPacket, SharedContextPacketType, SharedContextPeer, SharedContextPeerSummary, SharedContextProduct, SharedContextRole, SharedContextSurface, SharedContextTask, SharedContextTaskStatus, SyncOperationType, SyncQueueOperation, SyncScope } from "./protocol.js";
+export interface DurableObjectInput {
+    id?: string;
+    kind: DurableObjectKind | string;
+    label: string;
+    source?: string;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface ObjectEdgeInput {
+    id?: string;
+    fromId: string;
+    toId: string;
+    edgeType: string;
+    confidence?: number;
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface ExecutionReceiptInput {
+    id?: string;
+    runId?: string | null;
+    traceId?: string | null;
+    stepId?: string | null;
+    objectId?: string | null;
+    toolName?: string | null;
+    actionType: string;
+    summary: string;
+    input?: unknown;
+    output?: unknown;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface LocalArtifactInput {
+    id?: string;
+    runId?: string | null;
+    objectId?: string | null;
+    kind: string;
+    path?: string | null;
+    summary?: string | null;
+    verificationStatus?: string;
+    content?: string | null;
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface LocalOutcomeInput {
+    id?: string;
+    runId?: string | null;
+    objectId?: string | null;
+    outcomeType: string;
+    headline: string;
+    userValue?: string | null;
+    stakeholderValue?: string | null;
+    status?: string;
+    evidence?: unknown[];
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface DeviceBindingInput {
+    deviceId: string;
+    deviceName: string;
+    platform?: string | null;
+    appVersion?: string | null;
+    bridgeUrl?: string | null;
+    deviceToken?: string | null;
+    bindingStatus?: "unpaired" | "paired" | "revoked";
+    metadata?: Record<string, unknown>;
+}
+export interface AccountBindingInput {
+    deviceId: string;
+    userId: string;
+    workspaceId?: string | null;
+    scopes: SyncScope[];
+    syncEnabled?: boolean;
+    syncMode?: "offline" | "connected" | "cloud";
+    metadata?: Record<string, unknown>;
+}
+export interface SharedContextPeerInput {
+    peerId?: string;
+    product: SharedContextProduct;
+    tenantId?: string | null;
+    workspaceId?: string | null;
+    surface: SharedContextSurface;
+    role: SharedContextRole;
+    capabilities?: string[];
+    contextScopes?: string[];
+    status?: SharedContextPeer["status"];
+    summary?: SharedContextPeerSummary;
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface SharedContextPeerFilters {
+    product?: SharedContextProduct;
+    workspaceId?: string | null;
+    tenantId?: string | null;
+    role?: SharedContextRole;
+    surface?: SharedContextSurface;
+    status?: SharedContextPeer["status"];
+    capability?: string;
+    scope?: string;
+    limit?: number;
+}
+export interface SharedContextPacketInput {
+    contextId?: string;
+    contextType: SharedContextPacketType;
+    producerPeerId: string;
+    tenantId?: string | null;
+    workspaceId?: string | null;
+    scope?: string[];
+    subject: string;
+    summary: string;
+    claims?: string[];
+    evidenceRefs?: string[];
+    stateSnapshot?: Record<string, unknown>;
+    timeWindow?: Record<string, unknown>;
+    freshness?: Record<string, unknown>;
+    permissions?: Record<string, unknown>;
+    confidence?: number;
+    lineage?: Record<string, unknown>;
+    invalidates?: string[];
+    nextActions?: string[];
+    version?: number;
+    status?: SharedContextPacket["status"];
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface SharedContextPacketQuery {
+    contextType?: SharedContextPacketType;
+    producerPeerId?: string;
+    requestingPeerId?: string;
+    tenantId?: string | null;
+    workspaceId?: string | null;
+    status?: SharedContextPacket["status"];
+    scopeIncludes?: string;
+    subjectIncludes?: string;
+    limit?: number;
+}
+export interface SharedContextPacketResource {
+    packet: SharedContextPacket;
+    resourceUri: string;
+    pullQuery: {
+        contextType: SharedContextPacket["contextType"];
+        producerPeerId: string;
+        workspaceId?: string;
+        tenantId?: string;
+        scopeIncludes?: string;
+        subjectIncludes: string;
+    };
+    subscriptionQuery: {
+        peerId?: string;
+        workspaceId?: string;
+        contextType: SharedContextPacket["contextType"];
+        producerPeerId: string;
+        scopeIncludes?: string;
+        subjectIncludes: string;
+        eventTypes: string[];
+    };
+}
+export interface SharedContextSubscriptionQuery extends SharedContextPacketQuery {
+    peerId?: string;
+    eventTypes?: string[];
+    taskType?: string;
+    messageClass?: SharedContextMessageClass;
+}
+export interface SharedContextSubscriptionManifest {
+    peerId?: string;
+    snapshotQuery: {
+        limit: number;
+        peerId?: string;
+        workspaceId?: string;
+        contextType?: SharedContextPacket["contextType"];
+        producerPeerId?: string;
+        scopeIncludes?: string;
+        subjectIncludes?: string;
+        taskType?: string;
+        messageClass?: SharedContextMessageClass;
+    };
+    pullQuery: SharedContextPacketQuery;
+    subscriptionQuery: {
+        peerId?: string;
+        workspaceId?: string;
+        contextType?: SharedContextPacket["contextType"];
+        producerPeerId?: string;
+        scopeIncludes?: string;
+        subjectIncludes?: string;
+        taskType?: string;
+        messageClass?: SharedContextMessageClass;
+        eventTypes: string[];
+    };
+    packetResources: Array<{
+        contextId: string;
+        contextType: SharedContextPacket["contextType"];
+        subject: string;
+        resourceUri: string;
+    }>;
+}
+export interface SharedContextTaskInput {
+    taskId?: string;
+    taskType: string;
+    proposerPeerId: string;
+    assigneePeerId: string;
+    status?: SharedContextTaskStatus;
+    taskSpec?: Record<string, unknown>;
+    inputContextIds?: string[];
+    outputContextId?: string | null;
+    reason?: string | null;
+    metadata?: Record<string, unknown>;
+    queueForSync?: boolean;
+}
+export interface SharedContextScopedSnapshotFilters extends SharedContextSubscriptionQuery {
+    limit?: number;
+}
+export declare function getSharedContextEventBus(): EventEmitter;
+export declare function upsertDurableObject(input: DurableObjectInput): {
+    objectId: string;
+    queuedSyncId?: string;
+};
+export declare function linkDurableObjects(input: ObjectEdgeInput): {
+    edgeId: string;
+    queuedSyncId?: string;
+};
+export declare function recordExecutionReceipt(input: ExecutionReceiptInput): {
+    receiptId: string;
+    queuedSyncId?: string;
+};
+export declare function recordLocalArtifact(input: LocalArtifactInput): {
+    artifactId: string;
+    queuedSyncId?: string;
+};
+export declare function recordLocalOutcome(input: LocalOutcomeInput): {
+    outcomeId: string;
+    queuedSyncId?: string;
+};
+export declare function upsertDeviceBinding(input: DeviceBindingInput): void;
+export declare function bindDeviceToAccount(input: AccountBindingInput): {
+    bindingId: string;
+};
+export declare function getActiveAccountBinding(deviceId?: string): null | {
+    bindingId: string;
+    deviceId: string;
+    userId: string;
+    workspaceId: string | null;
+    scopes: SyncScope[];
+    syncEnabled: boolean;
+    syncMode: string;
+    lastSyncedAt: string | null;
+    revokedAt: string | null;
+};
+export declare function getDeviceBinding(deviceId: string): null | {
+    deviceId: string;
+    deviceName: string;
+    platform: string | null;
+    appVersion: string | null;
+    bridgeUrl: string | null;
+    deviceToken: string | null;
+    bindingStatus: string;
+    lastSeenAt: string | null;
+};
+export declare function enqueueSyncOperation(input: {
+    objectId: string | null;
+    objectKind: DurableObjectKind | string;
+    opType: SyncOperationType | string;
+    payload: Record<string, unknown>;
+}): {
+    queueId: string;
+    payloadHash: string;
+};
+export declare function listPendingSyncOperations(limit?: number): SyncQueueOperation[];
+export declare function markSyncAttempt(queueIds: string[], error?: string): void;
+export declare function acknowledgeSyncOperations(args: {
+    queueIds: string[];
+    serverReceiptId?: string;
+    deviceId?: string;
+    userId?: string;
+    workspaceId?: string;
+    detail?: Record<string, unknown>;
+}): void;
+export declare function failSyncOperations(args: {
+    rejected: Array<{
+        id: string;
+        reason: string;
+    }>;
+    deviceId?: string;
+    userId?: string;
+    workspaceId?: string;
+}): void;
+export declare function getSyncBridgeStatus(deviceId?: string): {
+    mode: "offline" | "connected";
+    activeBinding: ReturnType<typeof getActiveAccountBinding>;
+    pendingCount: number;
+    retryCount: number;
+    acknowledgedCount: number;
+    lastAcknowledgedAt: string | null;
+};
+export declare function registerSharedContextPeer(input: SharedContextPeerInput): {
+    peerId: string;
+    queuedSyncId?: string;
+};
+export declare function heartbeatSharedContextPeer(peerId: string, summary?: SharedContextPeerSummary): {
+    peerId: string;
+    lastHeartbeatAt: string;
+};
+export declare function listSharedContextPeers(filters?: SharedContextPeerFilters): SharedContextPeer[];
+export declare function getSharedContextPeer(peerId: string): SharedContextPeer | null;
+export declare function getSharedContextPacket(contextId: string, requestingPeerId?: string): SharedContextPacket | null;
+export declare function buildSharedContextPacketResource(packet: SharedContextPacket, requestingPeerId?: string): SharedContextPacketResource;
+export declare function getSharedContextPacketResource(contextId: string, requestingPeerId?: string): SharedContextPacketResource | null;
+export declare function buildSharedContextSubscriptionManifest(query?: SharedContextSubscriptionQuery): SharedContextSubscriptionManifest;
+export declare function publishSharedContextPacket(input: SharedContextPacketInput): {
+    contextId: string;
+    queuedSyncId?: string;
+};
+export declare function pullSharedContextPackets(query?: SharedContextPacketQuery): SharedContextPacket[];
+export declare function acknowledgeSharedContextPacket(contextId: string, peerId: string, detail?: Record<string, unknown>): {
+    ackId: string;
+    queuedSyncId?: string;
+};
+export declare function invalidateSharedContextPacket(contextId: string, producerPeerId: string, reason: string, invalidates?: string[]): {
+    contextId: string;
+    queuedSyncId: string;
+};
+export declare function sendSharedContextMessage(input: {
+    fromPeerId: string;
+    toPeerId: string;
+    messageClass: SharedContextMessageClass;
+    payload: Record<string, unknown>;
+    queueForSync?: boolean;
+}): {
+    messageId: string;
+    queuedSyncId?: string;
+};
+export declare function listSharedContextMessages(peerId: string, unreadOnly?: boolean): Array<{
+    messageId: string;
+    fromPeerId: string;
+    toPeerId: string;
+    messageClass: SharedContextMessageClass;
+    payload: Record<string, unknown>;
+    status: string;
+    createdAt: string;
+}>;
+export declare function proposeSharedContextTask(input: SharedContextTaskInput): {
+    taskId: string;
+    queuedSyncId?: string;
+};
+export declare function acceptSharedContextTask(taskId: string, peerId: string): {
+    task: SharedContextTask;
+    queuedSyncId: string;
+};
+export declare function rejectSharedContextTask(taskId: string, peerId: string, reason: string): {
+    task: SharedContextTask;
+    queuedSyncId: string;
+};
+export declare function completeSharedContextTask(taskId: string, peerId: string, outputContextId?: string | null): {
+    task: SharedContextTask;
+    queuedSyncId: string;
+};
+export declare function escalateSharedContextTask(taskId: string, peerId: string, reason: string, outputContextId?: string | null): {
+    task: SharedContextTask;
+    queuedSyncId: string;
+};
+export declare function getSharedContextSnapshot(limit?: number, requestingPeerId?: string): {
+    peers: SharedContextPeer[];
+    recentPackets: SharedContextPacket[];
+    recentTasks: SharedContextTask[];
+    recentMessages: Array<{
+        messageId: string;
+        fromPeerId: string;
+        toPeerId: string;
+        messageClass: SharedContextMessageClass;
+        payload: Record<string, unknown>;
+        status: string;
+        createdAt: string;
+    }>;
+    counts: {
+        activePeers: number;
+        activePackets: number;
+        invalidatedPackets: number;
+        openTasks: number;
+        unreadMessages: number;
+    };
+};
+export declare function getSharedContextScopedSnapshot(filters?: SharedContextScopedSnapshotFilters): ReturnType<typeof getSharedContextSnapshot>;