@kinqs/brainrouter-mcp-server 0.3.4

package/dist/memory/validation.d.ts

@@ -0,0 +1,441 @@
+import { z } from "zod";
+import type { SqliteMemoryStore } from "./store/sqlite.js";
+export declare const MemoryTypeSchema: z.ZodEnum<["persona", "episodic", "instruction", "skill_context"]>;
+export declare const L1MemoryItemSchema: z.ZodObject<{
+    content: z.ZodString;
+    type: z.ZodEnum<["persona", "episodic", "instruction", "skill_context"]>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, "strip", z.ZodTypeAny, {
+    type: "persona" | "episodic" | "instruction" | "skill_context";
+    content: string;
+    skillTag: string;
+    priority: number;
+    metadata: Record<string, any>;
+}, {
+    type: "persona" | "episodic" | "instruction" | "skill_context";
+    content: string;
+    skillTag?: string | undefined;
+    priority?: number | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export declare const L1SceneGroupSchema: z.ZodObject<{
+    sceneName: z.ZodString;
+    memories: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        type: z.ZodEnum<["persona", "episodic", "instruction", "skill_context"]>;
+        priority: z.ZodDefault<z.ZodNumber>;
+        skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "persona" | "episodic" | "instruction" | "skill_context";
+        content: string;
+        skillTag: string;
+        priority: number;
+        metadata: Record<string, any>;
+    }, {
+        type: "persona" | "episodic" | "instruction" | "skill_context";
+        content: string;
+        skillTag?: string | undefined;
+        priority?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    sceneName: string;
+    memories: {
+        type: "persona" | "episodic" | "instruction" | "skill_context";
+        content: string;
+        skillTag: string;
+        priority: number;
+        metadata: Record<string, any>;
+    }[];
+}, {
+    sceneName: string;
+    memories: {
+        type: "persona" | "episodic" | "instruction" | "skill_context";
+        content: string;
+        skillTag?: string | undefined;
+        priority?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }[];
+}>;
+export declare const L1CommitPayloadSchema: z.ZodObject<{
+    userId: z.ZodString;
+    sessionKey: z.ZodString;
+    sessionId: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    sourceL0Ids: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    scenes: z.ZodArray<z.ZodObject<{
+        sceneName: z.ZodString;
+        memories: z.ZodArray<z.ZodObject<{
+            content: z.ZodString;
+            type: z.ZodEnum<["persona", "episodic", "instruction", "skill_context"]>;
+            priority: z.ZodDefault<z.ZodNumber>;
+            skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "persona" | "episodic" | "instruction" | "skill_context";
+            content: string;
+            skillTag: string;
+            priority: number;
+            metadata: Record<string, any>;
+        }, {
+            type: "persona" | "episodic" | "instruction" | "skill_context";
+            content: string;
+            skillTag?: string | undefined;
+            priority?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sceneName: string;
+        memories: {
+            type: "persona" | "episodic" | "instruction" | "skill_context";
+            content: string;
+            skillTag: string;
+            priority: number;
+            metadata: Record<string, any>;
+        }[];
+    }, {
+        sceneName: string;
+        memories: {
+            type: "persona" | "episodic" | "instruction" | "skill_context";
+            content: string;
+            skillTag?: string | undefined;
+            priority?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    sessionKey: string;
+    sessionId: string;
+    sourceL0Ids: string[];
+    scenes: {
+        sceneName: string;
+        memories: {
+            type: "persona" | "episodic" | "instruction" | "skill_context";
+            content: string;
+            skillTag: string;
+            priority: number;
+            metadata: Record<string, any>;
+        }[];
+    }[];
+}, {
+    userId: string;
+    sessionKey: string;
+    scenes: {
+        sceneName: string;
+        memories: {
+            type: "persona" | "episodic" | "instruction" | "skill_context";
+            content: string;
+            skillTag?: string | undefined;
+            priority?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }[];
+    }[];
+    sessionId?: string | undefined;
+    sourceL0Ids?: string[] | undefined;
+}>;
+export declare const ContradictionDecisionItemSchema: z.ZodObject<{
+    newRecordId: z.ZodString;
+    existingRecordId: z.ZodString;
+    decision: z.ZodEnum<["no_conflict", "temporal_update", "genuine_conflict"]>;
+    reason: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    newRecordId: string;
+    existingRecordId: string;
+    decision: "temporal_update" | "genuine_conflict" | "no_conflict";
+    reason?: string | undefined;
+}, {
+    newRecordId: string;
+    existingRecordId: string;
+    decision: "temporal_update" | "genuine_conflict" | "no_conflict";
+    confidence?: number | undefined;
+    reason?: string | undefined;
+}>;
+export declare const ContradictionDecisionCommitSchema: z.ZodObject<{
+    userId: z.ZodString;
+    decisions: z.ZodArray<z.ZodObject<{
+        newRecordId: z.ZodString;
+        existingRecordId: z.ZodString;
+        decision: z.ZodEnum<["no_conflict", "temporal_update", "genuine_conflict"]>;
+        reason: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        newRecordId: string;
+        existingRecordId: string;
+        decision: "temporal_update" | "genuine_conflict" | "no_conflict";
+        reason?: string | undefined;
+    }, {
+        newRecordId: string;
+        existingRecordId: string;
+        decision: "temporal_update" | "genuine_conflict" | "no_conflict";
+        confidence?: number | undefined;
+        reason?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    decisions: {
+        confidence: number;
+        newRecordId: string;
+        existingRecordId: string;
+        decision: "temporal_update" | "genuine_conflict" | "no_conflict";
+        reason?: string | undefined;
+    }[];
+}, {
+    userId: string;
+    decisions: {
+        newRecordId: string;
+        existingRecordId: string;
+        decision: "temporal_update" | "genuine_conflict" | "no_conflict";
+        confidence?: number | undefined;
+        reason?: string | undefined;
+    }[];
+}>;
+export declare const GraphEntityItemSchema: z.ZodObject<{
+    entity: z.ZodString;
+    type: z.ZodDefault<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    sourceRecordId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    entity: string;
+    skillTag: string;
+    confidence: number;
+    sourceRecordId?: string | undefined;
+}, {
+    entity: string;
+    type?: string | undefined;
+    skillTag?: string | undefined;
+    confidence?: number | undefined;
+    sourceRecordId?: string | undefined;
+}>;
+export declare const GraphRelationItemSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    relation: z.ZodDefault<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    sourceRecordId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    skillTag: string;
+    confidence: number;
+    from: string;
+    to: string;
+    relation: string;
+    sourceRecordId?: string | undefined;
+}, {
+    from: string;
+    to: string;
+    skillTag?: string | undefined;
+    confidence?: number | undefined;
+    sourceRecordId?: string | undefined;
+    relation?: string | undefined;
+}>;
+export declare const GraphCommitSchema: z.ZodObject<{
+    userId: z.ZodString;
+    sourceRecordId: z.ZodOptional<z.ZodString>;
+    entities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        entity: z.ZodString;
+        type: z.ZodDefault<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        sourceRecordId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        entity: string;
+        skillTag: string;
+        confidence: number;
+        sourceRecordId?: string | undefined;
+    }, {
+        entity: string;
+        type?: string | undefined;
+        skillTag?: string | undefined;
+        confidence?: number | undefined;
+        sourceRecordId?: string | undefined;
+    }>, "many">>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        relation: z.ZodDefault<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        skillTag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        sourceRecordId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        skillTag: string;
+        confidence: number;
+        from: string;
+        to: string;
+        relation: string;
+        sourceRecordId?: string | undefined;
+    }, {
+        from: string;
+        to: string;
+        skillTag?: string | undefined;
+        confidence?: number | undefined;
+        sourceRecordId?: string | undefined;
+        relation?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    entities: {
+        type: string;
+        entity: string;
+        skillTag: string;
+        confidence: number;
+        sourceRecordId?: string | undefined;
+    }[];
+    relations: {
+        skillTag: string;
+        confidence: number;
+        from: string;
+        to: string;
+        relation: string;
+        sourceRecordId?: string | undefined;
+    }[];
+    sourceRecordId?: string | undefined;
+}, {
+    userId: string;
+    sourceRecordId?: string | undefined;
+    entities?: {
+        entity: string;
+        type?: string | undefined;
+        skillTag?: string | undefined;
+        confidence?: number | undefined;
+        sourceRecordId?: string | undefined;
+    }[] | undefined;
+    relations?: {
+        from: string;
+        to: string;
+        skillTag?: string | undefined;
+        confidence?: number | undefined;
+        sourceRecordId?: string | undefined;
+        relation?: string | undefined;
+    }[] | undefined;
+}>;
+export declare const L2RenameItemSchema: z.ZodObject<{
+    oldName: z.ZodString;
+    newName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    oldName: string;
+    newName: string;
+}, {
+    oldName: string;
+    newName: string;
+}>;
+export declare const L2SceneItemSchema: z.ZodObject<{
+    sceneName: z.ZodString;
+    summaryMd: z.ZodString;
+    heatScore: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sceneName: string;
+    summaryMd: string;
+    heatScore?: number | undefined;
+}, {
+    sceneName: string;
+    summaryMd: string;
+    heatScore?: number | undefined;
+}>;
+export declare const L2MergeItemSchema: z.ZodObject<{
+    sceneIds: z.ZodArray<z.ZodString, "many">;
+    mergedSummaryMd: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sceneIds: string[];
+    mergedSummaryMd: string;
+}, {
+    sceneIds: string[];
+    mergedSummaryMd: string;
+}>;
+export declare const L2CommitSchema: z.ZodObject<{
+    userId: z.ZodString;
+    renames: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        oldName: z.ZodString;
+        newName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        oldName: string;
+        newName: string;
+    }, {
+        oldName: string;
+        newName: string;
+    }>, "many">>>;
+    scenes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sceneName: z.ZodString;
+        summaryMd: z.ZodString;
+        heatScore: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        sceneName: string;
+        summaryMd: string;
+        heatScore?: number | undefined;
+    }, {
+        sceneName: string;
+        summaryMd: string;
+        heatScore?: number | undefined;
+    }>, "many">>>;
+    merges: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sceneIds: z.ZodArray<z.ZodString, "many">;
+        mergedSummaryMd: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sceneIds: string[];
+        mergedSummaryMd: string;
+    }, {
+        sceneIds: string[];
+        mergedSummaryMd: string;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    scenes: {
+        sceneName: string;
+        summaryMd: string;
+        heatScore?: number | undefined;
+    }[];
+    renames: {
+        oldName: string;
+        newName: string;
+    }[];
+    merges: {
+        sceneIds: string[];
+        mergedSummaryMd: string;
+    }[];
+}, {
+    userId: string;
+    scenes?: {
+        sceneName: string;
+        summaryMd: string;
+        heatScore?: number | undefined;
+    }[] | undefined;
+    renames?: {
+        oldName: string;
+        newName: string;
+    }[] | undefined;
+    merges?: {
+        sceneIds: string[];
+        mergedSummaryMd: string;
+    }[] | undefined;
+}>;
+export declare const L3CommitSchema: z.ZodObject<{
+    userId: z.ZodString;
+    personaMd: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    personaMd: string;
+}, {
+    userId: string;
+    personaMd: string;
+}>;
+export declare function normalizeSceneName(name: string): string;
+export declare function normalizeEntityName(name: string): string;
+export declare function normalizeSkillTag(tag: string): string;
+export declare function normalizeMemoryContent(content: string): string;
+/**
+ * Ensures multi-tenant isolation by checking that all referenced L1 record IDs
+ * belong strictly to the provided userId. Throws an error if ownership is violated.
+ */
+export declare function validateL1RecordOwnership(store: SqliteMemoryStore, userId: string, recordIds: string[]): void;
+/**
+ * Checks if a specific L0 record belongs to the user.
+ */
+export declare function validateL0RecordOwnership(store: SqliteMemoryStore, userId: string, recordIds: string[]): void;

package/dist/memory/validation.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+// ============================
+// Shared Zod Schemas
+// ============================
+export const MemoryTypeSchema = z.enum(["persona", "episodic", "instruction", "skill_context"]);
+export const L1MemoryItemSchema = z.object({
+    content: z.string().min(1, "Memory content cannot be empty"),
+    type: MemoryTypeSchema,
+    priority: z.number().int().min(0).max(100).default(50),
+    skillTag: z.string().optional().default(""),
+    metadata: z.record(z.any()).optional().default({}),
+});
+export const L1SceneGroupSchema = z.object({
+    sceneName: z.string().min(1, "Scene name cannot be empty"),
+    memories: z.array(L1MemoryItemSchema).min(1, "Scene must contain at least one memory"),
+});
+export const L1CommitPayloadSchema = z.object({
+    userId: z.string().min(1, "userId is required"),
+    sessionKey: z.string().min(1, "sessionKey is required"),
+    sessionId: z.string().optional().default(""),
+    sourceL0Ids: z.array(z.string()).optional().default([]),
+    scenes: z.array(L1SceneGroupSchema).min(1, "At least one scene group is required"),
+});
+export const ContradictionDecisionItemSchema = z.object({
+    newRecordId: z.string().min(1, "newRecordId is required"),
+    existingRecordId: z.string().min(1, "existingRecordId is required"),
+    decision: z.enum(["no_conflict", "temporal_update", "genuine_conflict"]),
+    reason: z.string().optional(),
+    confidence: z.number().min(0).max(1).default(1.0),
+});
+export const ContradictionDecisionCommitSchema = z.object({
+    userId: z.string().min(1, "userId is required"),
+    decisions: z.array(ContradictionDecisionItemSchema).min(1, "At least one decision is required"),
+});
+export const GraphEntityItemSchema = z.object({
+    entity: z.string().min(1, "Entity name cannot be empty"),
+    type: z.string().default("concept"),
+    confidence: z.number().min(0).max(1).default(1.0),
+    skillTag: z.string().optional().default(""),
+    sourceRecordId: z.string().optional(),
+});
+export const GraphRelationItemSchema = z.object({
+    from: z.string().min(1, "from entity name is required"),
+    to: z.string().min(1, "to entity name is required"),
+    relation: z.string().default("relates_to"),
+    confidence: z.number().min(0).max(1).default(1.0),
+    skillTag: z.string().optional().default(""),
+    sourceRecordId: z.string().optional(),
+});
+export const GraphCommitSchema = z.object({
+    userId: z.string().min(1, "userId is required"),
+    sourceRecordId: z.string().optional(),
+    entities: z.array(GraphEntityItemSchema).default([]),
+    relations: z.array(GraphRelationItemSchema).default([]),
+});
+export const L2RenameItemSchema = z.object({
+    oldName: z.string().min(1),
+    newName: z.string().min(1),
+});
+export const L2SceneItemSchema = z.object({
+    sceneName: z.string().min(1),
+    summaryMd: z.string().min(1),
+    heatScore: z.number().min(0).max(100).optional(),
+});
+export const L2MergeItemSchema = z.object({
+    sceneIds: z.array(z.string()).min(2, "At least two scene IDs are required to merge"),
+    mergedSummaryMd: z.string().min(1),
+});
+export const L2CommitSchema = z.object({
+    userId: z.string().min(1, "userId is required"),
+    renames: z.array(L2RenameItemSchema).optional().default([]),
+    scenes: z.array(L2SceneItemSchema).optional().default([]),
+    merges: z.array(L2MergeItemSchema).optional().default([]),
+});
+export const L3CommitSchema = z.object({
+    userId: z.string().min(1, "userId is required"),
+    personaMd: z.string().min(1, "personaMd cannot be empty"),
+});
+// ============================
+// Normalization Helpers
+// ============================
+export function normalizeSceneName(name) {
+    const trimmed = name.trim();
+    return trimmed === "" ? "general" : trimmed;
+}
+export function normalizeEntityName(name) {
+    const trimmed = name.trim();
+    return trimmed === "" ? "unknown" : trimmed;
+}
+export function normalizeSkillTag(tag) {
+    return tag.trim().toLowerCase();
+}
+export function normalizeMemoryContent(content) {
+    return content.trim();
+}
+// ============================
+// Ownership & Tenant Isolation Validation
+// ============================
+/**
+ * Ensures multi-tenant isolation by checking that all referenced L1 record IDs
+ * belong strictly to the provided userId. Throws an error if ownership is violated.
+ */
+export function validateL1RecordOwnership(store, userId, recordIds) {
+    if (recordIds.length === 0)
+        return;
+    const placeholders = recordIds.map(() => "?").join(",");
+    const stmt = store.db.prepare(`SELECT record_id, user_id FROM l1_records WHERE record_id IN (${placeholders})`);
+    const rows = stmt.all(...recordIds);
+    for (const row of rows) {
+        if (row.user_id !== userId) {
+            throw new Error(`[Tenant Isolation Violation] Record ${row.record_id} is owned by user ${row.user_id}, but requested by ${userId}`);
+        }
+    }
+}
+/**
+ * Checks if a specific L0 record belongs to the user.
+ */
+export function validateL0RecordOwnership(store, userId, recordIds) {
+    if (recordIds.length === 0)
+        return;
+    const placeholders = recordIds.map(() => "?").join(",");
+    const stmt = store.db.prepare(`SELECT record_id, user_id FROM l0_conversations WHERE record_id IN (${placeholders})`);
+    const rows = stmt.all(...recordIds);
+    for (const row of rows) {
+        if (row.user_id !== userId) {
+            throw new Error(`[Tenant Isolation Violation] L0 Message ${row.record_id} belongs to user ${row.user_id}, but requested by ${userId}`);
+        }
+    }
+}

package/dist/memory/working/canvas.d.ts

@@ -0,0 +1,5 @@
+import type { WorkingStep } from "./step-log.js";
+export declare function buildWorkingCanvas(steps: WorkingStep[]): string;
+export declare function buildAnnotatedCanvas(steps: WorkingStep[], activeNodeId?: string): string;
+export declare function writeWorkingCanvas(workDir: string, steps: WorkingStep[]): string;
+export declare function readWorkingCanvas(workDir: string): string;

package/dist/memory/working/canvas.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+function escapeMermaidLabel(value) {
+    return value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("\"", "'")
+        .replaceAll("\n", " ")
+        .slice(0, 96);
+}
+export function buildWorkingCanvas(steps) {
+    return buildAnnotatedCanvas(steps);
+}
+export function buildAnnotatedCanvas(steps, activeNodeId) {
+    const lines = ["flowchart TD"];
+    if (steps.length === 0) {
+        lines.push("  empty[\"No working memory steps yet\"]");
+        return lines.join("\n");
+    }
+    for (const step of steps) {
+        const label = escapeMermaidLabel(`${step.title}\\n${step.summary}`);
+        const prefix = step.nodeId === activeNodeId ? "🌟 " : "";
+        lines.push(`  ${step.nodeId}["${prefix}${label}"]`);
+    }
+    for (let index = 1; index < steps.length; index += 1) {
+        lines.push(`  ${steps[index - 1].nodeId} --> ${steps[index].nodeId}`);
+    }
+    if (activeNodeId && steps.some((step) => step.nodeId === activeNodeId)) {
+        lines.push(`  style ${activeNodeId} fill:#2b6cb0,stroke:#3182ce,stroke-width:2px,color:#fff`);
+    }
+    return lines.join("\n");
+}
+export function writeWorkingCanvas(workDir, steps) {
+    const canvas = buildWorkingCanvas(steps);
+    fs.mkdirSync(workDir, { recursive: true });
+    fs.writeFileSync(path.join(workDir, "canvas.mmd"), canvas, "utf8");
+    return canvas;
+}
+export function readWorkingCanvas(workDir) {
+    const canvasPath = path.join(workDir, "canvas.mmd");
+    if (!fs.existsSync(canvasPath))
+        return buildWorkingCanvas([]);
+    return fs.readFileSync(canvasPath, "utf8");
+}

package/dist/memory/working/offload.d.ts

@@ -0,0 +1,71 @@
+import { type WorkingStep } from "./step-log.js";
+export type TokenPressureLevel = "none" | "mild" | "aggressive";
+export interface WorkingMemoryState {
+    sessionKey: string;
+    workDir: string;
+    pressureLevel: TokenPressureLevel;
+    contextWindowTokens: number;
+    estimatedTokens: number;
+    injectedState: {
+        currentNode?: WorkingStep;
+        recentSteps: WorkingStep[];
+        refs: Array<{
+            nodeId: string;
+            refPath?: string;
+            title: string;
+        }>;
+        rawPayloadsIncluded: false;
+    };
+    updatedAt: string;
+}
+export interface WorkingContextResult {
+    sessionKey: string;
+    workDir: string;
+    canvas: string;
+    annotatedCanvas?: string;
+    state: WorkingMemoryState;
+    steps: WorkingStep[];
+    ref?: {
+        nodeId: string;
+        path: string;
+        content: string;
+    };
+}
+export interface WorkingOffloadInput {
+    workspacePath?: string;
+    userId: string;
+    sessionKey: string;
+    payload: string;
+    title?: string;
+    summary?: string;
+    kind?: string;
+    contextWindowTokens?: number;
+    estimatedTokens?: number;
+    forceAggressive?: boolean;
+}
+export interface WorkingOffloadResult {
+    nodeId: string;
+    refPath: string;
+    pressureLevel: TokenPressureLevel;
+    canvas: string;
+    state: WorkingMemoryState;
+}
+export declare function detectTokenPressure(estimatedTokens: number, contextWindowTokens: number): TokenPressureLevel;
+export declare function getWorkingMemoryDir(workspacePath: string | undefined, userId: string, sessionKey: string): string;
+export declare function offloadWorkingPayload(input: WorkingOffloadInput): WorkingOffloadResult;
+export declare function getWorkingContext(workspacePath: string | undefined, userId: string, sessionKey: string, options?: {
+    nodeId?: string;
+    activeNodeId?: string;
+    contextWindowTokens?: number;
+    estimatedTokens?: number;
+}): WorkingContextResult;
+export declare function resetWorkingMemory(workspacePath: string | undefined, userId: string, sessionKey: string): {
+    deleted: boolean;
+    workDir: string;
+};
+export interface ActiveSessionInfo {
+    sessionKey: string;
+    workspaceId: string;
+    updatedAt: string;
+}
+export declare function listActiveSessions(userId: string): ActiveSessionInfo[];