@oscharko-dev/keiko-server 0.2.0

package/dist/memory-consolidation-handlers.js

@@ -0,0 +1,491 @@
+import { randomUUID } from "node:crypto";
+import { buildConsolidationJob, runConsolidation, transitionJob, } from "@oscharko-dev/keiko-memory-consolidation";
+import { MEMORY_SCOPE_KINDS, MEMORY_STATUSES, MEMORY_TYPES, } from "@oscharko-dev/keiko-contracts";
+import { errorBody } from "./routes.js";
+const MAX_BODY_BYTES = 64_000;
+const DEFAULT_JACCARD_THRESHOLD = 0.85;
+const DEFAULT_STALE_CONFIDENCE_THRESHOLD = 0.3;
+const DEFAULT_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+const DEFAULT_MAX_CLUSTERS_PER_RUN = 100;
+const DEFAULT_MAX_RECORDS_PER_RUN = 1_000;
+const MAX_CLUSTERS_PER_RUN_LIMIT = 1_000;
+const MAX_RECORDS_PER_RUN_LIMIT = 1_000;
+class BodyTooLargeError extends Error {
+    constructor() {
+        super("request body too large");
+        this.name = "BodyTooLargeError";
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRouteResult(value) {
+    return isRecord(value) && typeof value.status === "number";
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        let capped = false;
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > MAX_BODY_BYTES) {
+                if (!capped) {
+                    capped = true;
+                    chunks.length = 0;
+                    reject(new BodyTooLargeError());
+                    req.resume();
+                }
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            if (!capped)
+                resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        req.on("error", reject);
+    });
+}
+async function readJsonBody(req) {
+    let raw;
+    try {
+        raw = await readBody(req);
+    }
+    catch (error) {
+        if (error instanceof BodyTooLargeError) {
+            return { status: 413, body: errorBody("PAYLOAD_TOO_LARGE", "Request body too large.") };
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = raw.length === 0 ? {} : JSON.parse(raw);
+    }
+    catch {
+        return { status: 400, body: errorBody("BAD_REQUEST", "Request body is not valid JSON.") };
+    }
+    if (!isRecord(parsed)) {
+        return { status: 400, body: errorBody("BAD_REQUEST", "Request body must be a JSON object.") };
+    }
+    return parsed;
+}
+function resolveVault(deps) {
+    if (deps.memoryVault === undefined) {
+        return {
+            status: 503,
+            body: errorBody("MEMORY_UNAVAILABLE", "Memory vault is not configured."),
+        };
+    }
+    return deps.memoryVault;
+}
+function resolveJobRegistry(deps) {
+    if (deps.consolidationJobs === undefined) {
+        return {
+            status: 503,
+            body: errorBody("MEMORY_UNAVAILABLE", "Consolidation jobs are not configured."),
+        };
+    }
+    return deps.consolidationJobs;
+}
+function isScopeKind(value) {
+    return typeof value === "string" && MEMORY_SCOPE_KINDS.includes(value);
+}
+function readString(raw, key) {
+    const value = raw[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseScopedId(raw, key) {
+    const value = readString(raw, key);
+    return value ?? null;
+}
+function parseScopeWithId(raw, key, build) {
+    const value = parseScopedId(raw, key);
+    return value === null ? null : build(value);
+}
+function parseScope(raw) {
+    if (!isRecord(raw) || !isScopeKind(raw.kind))
+        return null;
+    if (raw.kind === "global")
+        return { kind: "global" };
+    if (raw.kind === "user") {
+        return parseScopeWithId(raw, "userId", (userId) => ({
+            kind: "user",
+            userId: userId,
+        }));
+    }
+    if (raw.kind === "workspace") {
+        return parseScopeWithId(raw, "workspaceId", (workspaceId) => ({
+            kind: "workspace",
+            workspaceId: workspaceId,
+        }));
+    }
+    if (raw.kind === "project") {
+        return parseScopeWithId(raw, "projectId", (projectId) => ({
+            kind: "project",
+            projectId: projectId,
+        }));
+    }
+    return parseScopeWithId(raw, "workflowDefinitionId", (workflowDefinitionId) => ({
+        kind: "workflow",
+        workflowDefinitionId: workflowDefinitionId,
+    }));
+}
+function parseScopes(raw) {
+    if (raw === undefined)
+        return [{ kind: "global" }];
+    if (!Array.isArray(raw) || raw.length === 0)
+        return null;
+    const scopes = [];
+    for (const item of raw) {
+        const scope = parseScope(item);
+        if (scope === null)
+            return null;
+        scopes.push(scope);
+    }
+    return scopes;
+}
+function parseTypes(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        return null;
+    const types = [];
+    for (const item of raw) {
+        if (typeof item !== "string" || !MEMORY_TYPES.includes(item)) {
+            return null;
+        }
+        types.push(item);
+    }
+    return types;
+}
+function parseStatuses(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        return null;
+    const statuses = [];
+    for (const item of raw) {
+        if (typeof item !== "string" || !MEMORY_STATUSES.includes(item)) {
+            return null;
+        }
+        statuses.push(item);
+    }
+    return statuses;
+}
+function parseOptionalNumber(raw) {
+    if (raw === undefined)
+        return undefined;
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+}
+function parseSettingsRecord(raw) {
+    if (raw === undefined)
+        return {};
+    return isRecord(raw) ? raw : null;
+}
+const SETTING_BOUNDS = {
+    jaccardThreshold: { lo: 0, hi: 1 },
+    staleConfidenceThreshold: { lo: 0, hi: 1 },
+    maxAgeMs: { lo: 0, hi: Number.MAX_SAFE_INTEGER },
+    maxClustersPerRun: { lo: 0, hi: MAX_CLUSTERS_PER_RUN_LIMIT, integerOnly: true },
+    maxRecordsPerRun: { lo: 0, hi: MAX_RECORDS_PER_RUN_LIMIT, integerOnly: true },
+};
+function resolveSetting(raw, key, fallback) {
+    const value = parseOptionalNumber(raw[key]);
+    if (value === null)
+        return null;
+    const n = value ?? fallback;
+    const bounds = SETTING_BOUNDS[key];
+    if (n < bounds.lo || n > bounds.hi)
+        return null;
+    if (bounds.integerOnly === true && !Number.isInteger(n))
+        return null;
+    return n;
+}
+function parseSettings(raw) {
+    const record = parseSettingsRecord(raw);
+    if (record === null) {
+        return badRequest("settings must be an object containing optional numeric consolidation settings.");
+    }
+    const keys = Object.keys(SETTING_BOUNDS);
+    const defaults = {
+        jaccardThreshold: DEFAULT_JACCARD_THRESHOLD,
+        staleConfidenceThreshold: DEFAULT_STALE_CONFIDENCE_THRESHOLD,
+        maxAgeMs: DEFAULT_MAX_AGE_MS,
+        maxClustersPerRun: DEFAULT_MAX_CLUSTERS_PER_RUN,
+        maxRecordsPerRun: DEFAULT_MAX_RECORDS_PER_RUN,
+    };
+    const result = {};
+    for (const key of keys) {
+        const value = resolveSetting(record, key, defaults[key]);
+        if (value === null) {
+            const bounds = SETTING_BOUNDS[key];
+            const extra = bounds.integerOnly === true ? ", integer" : "";
+            return badRequest(`settings.${key} must be a finite number in [${String(bounds.lo)}, ${String(bounds.hi)}]${extra}.`);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function badRequest(message) {
+    return { status: 400, body: errorBody("BAD_REQUEST", message) };
+}
+function parseSelection(raw) {
+    const scopes = parseScopes(raw.scopes);
+    if (scopes === null) {
+        return badRequest("scopes must be a non-empty array of valid MemoryScope.");
+    }
+    const types = parseTypes(raw.types);
+    if (raw.types !== undefined && types === null) {
+        return badRequest(`types must be an array of: ${MEMORY_TYPES.join(", ")}.`);
+    }
+    const statuses = parseStatuses(raw.statuses);
+    if (raw.statuses !== undefined && statuses === null) {
+        return badRequest(`statuses must be an array of: ${MEMORY_STATUSES.join(", ")}.`);
+    }
+    if (typeof raw.includeExpired !== "undefined" && typeof raw.includeExpired !== "boolean") {
+        return badRequest("includeExpired must be a boolean when provided.");
+    }
+    return {
+        scopes,
+        types: types ?? undefined,
+        statuses: statuses ?? undefined,
+        includeExpired: raw.includeExpired === true,
+    };
+}
+function parseCreateInput(raw) {
+    const selection = parseSelection(raw);
+    if (isRouteResult(selection))
+        return selection;
+    const settings = parseSettings(raw.settings);
+    if (isRouteResult(settings))
+        return settings;
+    return { selection, settings };
+}
+function loadSelectedMemories(vault, selection, maxRecords) {
+    const seen = new Map();
+    const statuses = selection.statuses?.filter((status) => status === "accepted") ?? ["accepted"];
+    if (statuses.length === 0 || maxRecords <= 0)
+        return { records: [], truncated: false };
+    const detectionLimit = maxRecords + 1;
+    for (const scope of selection.scopes) {
+        const remaining = detectionLimit - seen.size;
+        if (remaining <= 0)
+            break;
+        const records = vault.listMemoriesByScope(scope, {
+            ...(selection.types !== undefined ? { type: selection.types } : {}),
+            status: statuses,
+            includeExpired: selection.includeExpired,
+            limit: remaining,
+            orderBy: "updatedAt",
+            orderDir: "asc",
+        });
+        for (const record of records) {
+            seen.set(record.id, record);
+            if (seen.size >= detectionLimit)
+                break;
+        }
+    }
+    const sorted = [...seen.values()]
+        .sort((a, b) => {
+        if (a.updatedAt !== b.updatedAt)
+            return a.updatedAt - b.updatedAt;
+        return a.id.localeCompare(b.id);
+    })
+        .slice(0, maxRecords);
+    return {
+        records: sorted,
+        truncated: seen.size > maxRecords,
+    };
+}
+function redactJob(deps, record) {
+    return deps.redactor({
+        id: record.job.id,
+        state: record.job.state,
+        startedAt: record.job.startedAt,
+        completedAt: record.job.completedAt,
+        result: record.job.result,
+        error: record.job.error,
+        createdAt: record.createdAt,
+        selection: record.selection,
+        settings: record.settings,
+        memoryCount: record.memoryCount,
+        cancelRequested: record.cancelRequested,
+    });
+}
+function newMemoryEdgeId() {
+    return randomUUID();
+}
+function buildRunOptions(scheduledRecord, createdAt, settings) {
+    return {
+        nowMs: createdAt,
+        newEdgeId: newMemoryEdgeId,
+        newReviewItemId: () => randomUUID(),
+        jaccardThreshold: settings.jaccardThreshold,
+        staleConfidenceThreshold: settings.staleConfidenceThreshold,
+        maxAgeMs: settings.maxAgeMs,
+        maxClustersPerRun: settings.maxClustersPerRun,
+        maxRecordsPerRun: settings.maxRecordsPerRun,
+        // Capture the record reference at schedule-time rather than re-fetching via the registry on
+        // every poll — eliminates a theoretical race where the registry entry is replaced under the
+        // closure before the signal is first checked.
+        cancellationSignal: () => scheduledRecord?.cancelRequested === true,
+    };
+}
+function finalizeTerminalJob(registry, running, jobId, memories, result, selectionTruncated = false) {
+    const completedAt = Date.now();
+    const finalResult = selectionTruncated && !result.truncated ? { ...result, truncated: true } : result;
+    if (result.state === "completed") {
+        registry.complete(jobId, transitionJob(running, "completed", { completedAt, result: finalResult }), memories.length);
+        return;
+    }
+    if (result.state === "canceled") {
+        registry.complete(jobId, transitionJob(running, "canceled", { completedAt, result: finalResult }), memories.length);
+        return;
+    }
+    const message = "Consolidation run failed.";
+    registry.fail(jobId, transitionJob(running, "failed", { completedAt, result: finalResult, error: message }), message, memories.length);
+}
+function failScheduledJob(registry, running, jobId, memories, error) {
+    const completedAt = Date.now();
+    const message = error instanceof Error ? error.message : "Consolidation run failed unexpectedly.";
+    registry.fail(jobId, transitionJob(running, "failed", { completedAt, error: message }), message, memories.length);
+}
+function emptyConsolidationResult(state) {
+    return {
+        state,
+        edgesProposed: [],
+        updatesProposed: [],
+        staleFlags: [],
+        reviewItems: [],
+        clustersInspected: 0,
+        conflictPairsDetected: 0,
+        recordsInspected: 0,
+        truncated: false,
+        elapsedMs: 0,
+    };
+}
+function scheduleJob(deps, jobId, vault, selection, settings) {
+    const registry = deps.consolidationJobs;
+    if (registry === undefined)
+        return;
+    setImmediate(() => {
+        const queued = registry.get(jobId);
+        if (queued?.job.state !== "queued")
+            return;
+        if (queued.cancelRequested) {
+            const canceled = transitionJob(queued.job, "canceled", { completedAt: Date.now() });
+            registry.complete(jobId, canceled, 0);
+            return;
+        }
+        const loaded = loadSelectedMemories(vault, selection, settings.maxRecordsPerRun);
+        const memories = loaded.records;
+        const afterLoad = registry.get(jobId);
+        if (afterLoad?.job.state !== "queued")
+            return;
+        if (afterLoad.cancelRequested) {
+            const canceled = transitionJob(afterLoad.job, "canceled", { completedAt: Date.now() });
+            registry.complete(jobId, canceled, memories.length);
+            return;
+        }
+        if (memories.length === 0 || settings.maxClustersPerRun === 0) {
+            const result = emptyConsolidationResult("skipped");
+            const skipped = transitionJob(afterLoad.job, "skipped", {
+                completedAt: Date.now(),
+                result,
+            });
+            registry.complete(jobId, skipped, memories.length);
+            return;
+        }
+        const running = transitionJob(afterLoad.job, "running");
+        registry.setRunning(jobId, running);
+        const scheduledRecord = registry.get(jobId);
+        try {
+            const result = runConsolidation(memories, buildRunOptions(scheduledRecord, queued.createdAt, settings));
+            finalizeTerminalJob(registry, running, jobId, memories, result, loaded.truncated);
+        }
+        catch (error) {
+            failScheduledJob(registry, running, jobId, memories, error);
+        }
+    });
+}
+function registerJobLimit(error) {
+    return {
+        status: 409,
+        body: errorBody("CONSOLIDATION_JOB_LIMIT", error instanceof Error ? error.message : "Consolidation job limit reached."),
+    };
+}
+function createJobResponse(deps, record) {
+    return { status: 202, body: { job: redactJob(deps, record) } };
+}
+export async function handleCreateConsolidationJob(ctx, deps) {
+    const vault = resolveVault(deps);
+    if (isRouteResult(vault))
+        return vault;
+    const registry = resolveJobRegistry(deps);
+    if (isRouteResult(registry))
+        return registry;
+    const body = await readJsonBody(ctx.req);
+    if (isRouteResult(body))
+        return body;
+    const input = parseCreateInput(body);
+    if (isRouteResult(input))
+        return input;
+    const createdAt = Date.now();
+    const jobId = randomUUID();
+    const job = buildConsolidationJob(jobId, createdAt);
+    let record;
+    try {
+        record = registry.register({
+            job,
+            createdAt,
+            selection: input.selection,
+            settings: input.settings,
+            memoryCount: 0,
+        });
+    }
+    catch (error) {
+        return registerJobLimit(error);
+    }
+    scheduleJob(deps, jobId, vault, input.selection, input.settings);
+    return createJobResponse(deps, record);
+}
+export function handleGetConsolidationJob(ctx, deps) {
+    const registry = resolveJobRegistry(deps);
+    if (isRouteResult(registry))
+        return registry;
+    const jobId = ctx.params.jobId;
+    if (jobId === undefined) {
+        return { status: 404, body: errorBody("NOT_FOUND", "Consolidation job not found.") };
+    }
+    const record = registry.get(jobId);
+    if (record === undefined) {
+        return {
+            status: 404,
+            body: errorBody("NOT_FOUND", "Consolidation job not found."),
+        };
+    }
+    return { status: 200, body: { job: redactJob(deps, record) } };
+}
+export function handleCancelConsolidationJob(ctx, deps) {
+    const registry = resolveJobRegistry(deps);
+    if (isRouteResult(registry))
+        return registry;
+    const jobId = ctx.params.jobId;
+    if (jobId === undefined) {
+        return { status: 404, body: errorBody("NOT_FOUND", "Consolidation job not found.") };
+    }
+    const updated = registry.requestCancel(jobId);
+    if (updated === undefined) {
+        return {
+            status: 404,
+            body: errorBody("NOT_FOUND", "Consolidation job not found."),
+        };
+    }
+    if (updated.job.state === "queued") {
+        const canceled = transitionJob(updated.job, "canceled", { completedAt: Date.now() });
+        const finalRecord = registry.complete(updated.job.id, canceled, updated.memoryCount) ?? updated;
+        return { status: 202, body: { job: redactJob(deps, finalRecord) } };
+    }
+    return { status: 202, body: { job: redactJob(deps, updated) } };
+}

package/dist/memory-consolidation-registry.d.ts

@@ -0,0 +1,47 @@
+import type { ConsolidationJob } from "@oscharko-dev/keiko-memory-consolidation";
+export interface ConsolidationJobSettings {
+    readonly jaccardThreshold: number;
+    readonly staleConfidenceThreshold: number;
+    readonly maxAgeMs: number;
+    readonly maxClustersPerRun: number;
+    readonly maxRecordsPerRun: number;
+}
+export interface ConsolidationJobSelection {
+    readonly scopes: readonly import("@oscharko-dev/keiko-contracts").MemoryScope[];
+    readonly types?: readonly import("@oscharko-dev/keiko-contracts").MemoryType[] | undefined;
+    readonly statuses?: readonly import("@oscharko-dev/keiko-contracts").MemoryStatus[] | undefined;
+    readonly includeExpired: boolean;
+}
+export interface ConsolidationJobRecord {
+    readonly job: ConsolidationJob;
+    readonly createdAt: number;
+    readonly selection: ConsolidationJobSelection;
+    readonly settings: ConsolidationJobSettings;
+    readonly memoryCount: number;
+    readonly cancelRequested: boolean;
+}
+export interface RegisterConsolidationJobInput {
+    readonly job: ConsolidationJob;
+    readonly createdAt: number;
+    readonly selection: ConsolidationJobSelection;
+    readonly settings: ConsolidationJobSettings;
+    readonly memoryCount: number;
+}
+export interface ConsolidationJobRegistryOptions {
+    readonly maxJobs?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export declare class ConsolidationJobRegistryLimitError extends Error {
+    constructor(limit: number);
+}
+export interface ConsolidationJobRegistry {
+    readonly register: (input: RegisterConsolidationJobInput) => ConsolidationJobRecord;
+    readonly get: (jobId: string) => ConsolidationJobRecord | undefined;
+    readonly setRunning: (jobId: string, job: ConsolidationJob) => ConsolidationJobRecord | undefined;
+    readonly complete: (jobId: string, job: ConsolidationJob, memoryCount: number) => ConsolidationJobRecord | undefined;
+    readonly fail: (jobId: string, job: ConsolidationJob, error: string, memoryCount: number) => ConsolidationJobRecord | undefined;
+    readonly requestCancel: (jobId: string) => ConsolidationJobRecord | undefined;
+    readonly size: () => number;
+}
+export declare function createConsolidationJobRegistry(options?: ConsolidationJobRegistryOptions): ConsolidationJobRegistry;
+//# sourceMappingURL=memory-consolidation-registry.d.ts.map

package/dist/memory-consolidation-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-consolidation-registry.d.ts","sourceRoot":"","sources":["../src/memory-consolidation-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,0CAA0C,CAAC;AAElD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,+BAA+B,EAAE,WAAW,EAAE,CAAC;IAChF,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,OAAO,+BAA+B,EAAE,UAAU,EAAE,GAAG,SAAS,CAAC;IAC3F,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,OAAO,+BAA+B,EAAE,YAAY,EAAE,GAAG,SAAS,CAAC;IAChG,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBACxC,KAAK,EAAE,MAAM;CAIjC;AAwFD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,6BAA6B,KAAK,sBAAsB,CAAC;IACpF,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,sBAAsB,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,gBAAgB,KAAK,sBAAsB,GAAG,SAAS,CAAC;IAClG,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,gBAAgB,EACrB,WAAW,EAAE,MAAM,KAChB,sBAAsB,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,CACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,KAChB,sBAAsB,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,sBAAsB,GAAG,SAAS,CAAC;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC;CAC7B;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,wBAAwB,CAuC1B"}

package/dist/memory-consolidation-registry.js

@@ -0,0 +1,106 @@
+export class ConsolidationJobRegistryLimitError extends Error {
+    constructor(limit) {
+        super(`consolidation job registry limit reached (${String(limit)})`);
+        this.name = "ConsolidationJobRegistryLimitError";
+    }
+}
+const DEFAULT_MAX_JOBS = 32;
+function isTerminal(job) {
+    return (job.state === "completed" ||
+        job.state === "failed" ||
+        job.state === "canceled" ||
+        job.state === "skipped");
+}
+function oldestTerminalJobId(state) {
+    let candidateId;
+    let candidateTs = Number.POSITIVE_INFINITY;
+    for (const [jobId, record] of state.records) {
+        if (!isTerminal(record.job))
+            continue;
+        const ts = record.job.completedAt ?? record.createdAt;
+        if (ts < candidateTs) {
+            candidateTs = ts;
+            candidateId = jobId;
+        }
+    }
+    return candidateId;
+}
+function enforceCapacity(state) {
+    while (state.records.size >= state.maxJobs) {
+        const evictId = oldestTerminalJobId(state);
+        if (evictId === undefined) {
+            throw new ConsolidationJobRegistryLimitError(state.maxJobs);
+        }
+        state.records.delete(evictId);
+    }
+}
+function updateRecord(state, jobId, patch) {
+    const record = state.records.get(jobId);
+    if (record === undefined)
+        return undefined;
+    const next = { ...record, ...patch };
+    state.records.set(jobId, next);
+    return next;
+}
+function withElapsedMs(result, startedAt, completedAt) {
+    return { ...result, elapsedMs: Math.max(0, completedAt - startedAt) };
+}
+function createRegistryState(options) {
+    return {
+        records: new Map(),
+        maxJobs: options.maxJobs ?? DEFAULT_MAX_JOBS,
+        now: options.now ?? Date.now,
+    };
+}
+function finalizeJob(job, startedAt, completedAt, error) {
+    const result = job.result;
+    if (result === undefined) {
+        return error === undefined ? job : { ...job, error };
+    }
+    return {
+        ...job,
+        ...(error === undefined ? {} : { error }),
+        result: withElapsedMs(result, startedAt, completedAt),
+    };
+}
+export function createConsolidationJobRegistry(options = {}) {
+    const state = createRegistryState(options);
+    return {
+        register: (input) => {
+            enforceCapacity(state);
+            const record = {
+                job: input.job,
+                createdAt: input.createdAt,
+                selection: input.selection,
+                settings: input.settings,
+                memoryCount: input.memoryCount,
+                cancelRequested: false,
+            };
+            state.records.set(input.job.id, record);
+            return record;
+        },
+        get: (jobId) => state.records.get(jobId),
+        setRunning: (jobId, job) => updateRecord(state, jobId, { job }),
+        complete: (jobId, job, memoryCount) => {
+            const startedAt = job.startedAt ?? state.now();
+            const completedAt = job.completedAt ?? state.now();
+            const finalJob = finalizeJob(job, startedAt, completedAt);
+            return updateRecord(state, jobId, { job: finalJob, memoryCount });
+        },
+        fail: (jobId, job, error, memoryCount) => {
+            const startedAt = job.startedAt ?? state.now();
+            const completedAt = job.completedAt ?? state.now();
+            const finalJob = finalizeJob(job, startedAt, completedAt, error);
+            return updateRecord(state, jobId, { job: finalJob, memoryCount });
+        },
+        requestCancel: (jobId) => {
+            const record = state.records.get(jobId);
+            if (record === undefined)
+                return undefined;
+            if (record.cancelRequested)
+                return record;
+            return updateRecord(state, jobId, { cancelRequested: true });
+        },
+        size: () => state.records.size,
+    };
+}

package/dist/memory-conv-handlers.d.ts

@@ -0,0 +1,8 @@
+import { type MemoryQueryPort } from "@oscharko-dev/keiko-memory-retrieval";
+import type { MemoryVaultStore } from "@oscharko-dev/keiko-memory-vault";
+import type { UiHandlerDeps } from "./deps.js";
+import type { RouteContext, RouteResult } from "./routes.js";
+export declare function vaultAsQueryPort(vault: MemoryVaultStore): MemoryQueryPort;
+export declare function handleMemoryRetrieveContext(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
+export declare function handleMemoryCaptureFromConversation(ctx: RouteContext, deps: UiHandlerDeps): Promise<RouteResult>;
+//# sourceMappingURL=memory-conv-handlers.d.ts.map

package/dist/memory-conv-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-conv-handlers.d.ts","sourceRoot":"","sources":["../src/memory-conv-handlers.ts"],"names":[],"mappings":"AA0BA,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,sCAAsC,CAAC;AAgB9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAkH7D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,eAAe,CAezE;AAgJD,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAwCtB;AAkED,wBAAsB,mCAAmC,CACvD,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CA0BtB"}