@oscharko-dev/keiko-server 0.2.0

package/dist/memory-salience.js

@@ -0,0 +1,154 @@
+// Server-side orchestration for model-assisted salience capture (Keiko "learns from experience").
+//
+// After a chat turn, this module asks the model to extract durable, salient facts the USER stated
+// in natural conversation and persists them as `proposed` memory candidates — IN ADDITION to the
+// regex intent path in chat-handlers.ts. The capture filter is intentionally LOW; a later
+// decay/consolidation pass prunes.
+//
+// This is the model/IO boundary: the WHOLE body runs inside one try/catch so a model error, a
+// vault hiccup, or any other failure can NEVER throw into the chat path — it logs and returns [].
+import { randomUUID } from "node:crypto";
+import { redact } from "@oscharko-dev/keiko-security";
+import { extractSalientMemories, memoryTextEgressRejectionReason, } from "@oscharko-dev/keiko-memory-capture";
+import { currentRedactionSecrets } from "./deps.js";
+import { conversationMemoryScopes, } from "./memory-conversation-context.js";
+import { buildMemoryRecordFromProposal } from "./memory-record-builders.js";
+import { insertSalienceMemoryWithNoveltyGate } from "./memory-embedding.js";
+import { isPersistableMemoryCandidate, memoryCapturePolicyForDeps, SENSITIVE_MEMORY_REJECTION_REASON, } from "./memory-capture-policy.js";
+// Mirror of chat-handlers' private scopeLabel (decision 3 — mirrored rather than exported to keep
+// the modules decoupled). Pure and trivial.
+function scopeLabel(scope) {
+    switch (scope.kind) {
+        case "user":
+            return "User memory";
+        case "workspace":
+            return "Workspace memory";
+        case "project":
+            return "Project memory";
+        case "workflow":
+            return "Workflow memory";
+        case "global":
+            return "Global memory";
+    }
+}
+// Bounds the dedup corpus so the Jaccard loop stays cheap even for a large vault.
+const MAX_EXISTING_BODIES = 200;
+function gatherExistingBodies(vault, context) {
+    const seen = new Set();
+    for (const scope of conversationMemoryScopes(context)) {
+        for (const record of vault.listMemoriesByScope(scope)) {
+            seen.add(record.body);
+            if (seen.size >= MAX_EXISTING_BODIES) {
+                return [...seen];
+            }
+        }
+    }
+    return [...seen];
+}
+function buildSalienceContext(context) {
+    return {
+        userId: context.userId,
+        nowMs: Date.now(),
+        newMemoryId: () => randomUUID(),
+        newProposalId: () => randomUUID(),
+        workspaceId: context.workspaceId,
+        projectId: context.projectId,
+        conversationId: context.conversationId,
+    };
+}
+function buildCallModel(deps, modelId) {
+    const model = deps.modelPortFactory(modelId);
+    if (model === undefined) {
+        return null;
+    }
+    return async (system, user) => {
+        const response = await model.call({
+            modelId,
+            messages: [
+                { role: "system", content: system },
+                { role: "user", content: user },
+            ],
+            stream: false,
+        }, new AbortController().signal);
+        return response.content;
+    };
+}
+function redactedErrorMessage(error, deps) {
+    const message = error instanceof Error ? error.message : String(error);
+    return redact(message, currentRedactionSecrets(deps));
+}
+// Persists one salience candidate and returns its wire action, or null when the outcome is not a
+// candidate, no record could be built, or the candidate was merged into an existing semantic
+// near-duplicate (#204, O-F1) instead of stored. Embed-on-capture happens INSIDE the novelty gate:
+// the body is embedded once, used to detect a near-duplicate, and stored only when the record is
+// actually inserted. Graceful when no embedding model is configured (plain insert, no dedup).
+async function persistCandidate(deps, outcome, vault) {
+    if (outcome.kind !== "candidate") {
+        return null;
+    }
+    if (!isPersistableMemoryCandidate(outcome)) {
+        return { kind: "rejected", reason: SENSITIVE_MEMORY_REJECTION_REASON };
+    }
+    const proposalId = outcome.proposal.proposalId;
+    const record = buildMemoryRecordFromProposal(proposalId, outcome);
+    if (record === null) {
+        return null;
+    }
+    const { inserted } = await insertSalienceMemoryWithNoveltyGate(deps, vault, record);
+    if (inserted === null) {
+        // Near-duplicate of an existing in-scope memory: the canonical was reinforced, nothing new to
+        // surface. Over-capture is bounded at the encode boundary rather than deferred to a decay pass.
+        return null;
+    }
+    return {
+        kind: "candidate",
+        proposalId: String(inserted.id),
+        body: inserted.body,
+        scopeLabel: scopeLabel(inserted.scope),
+        requiresApproval: outcome.requiresApproval,
+    };
+}
+// Captures salient memories from a completed chat turn. Never throws — any failure (model error,
+// vault error, malformed output) yields [] so the chat response is unaffected.
+export async function captureSalientFromTurn(deps, request, context, modelId, assistantText) {
+    const vault = deps.memoryVault;
+    if (request.memory === undefined || !request.memory.enabled || vault === undefined) {
+        return [];
+    }
+    try {
+        const callModel = buildCallModel(deps, modelId);
+        if (callModel === null) {
+            return [];
+        }
+        const policy = memoryCapturePolicyForDeps(deps);
+        if (memoryTextEgressRejectionReason(request.content, policy) !== null) {
+            return [];
+        }
+        const outcomes = await extractSalientMemories({
+            userText: request.content,
+            assistantText,
+            existingBodies: gatherExistingBodies(vault, context),
+            context: buildSalienceContext(context),
+            policy,
+        }, {
+            callModel,
+            now: () => Date.now(),
+            newMemoryId: () => randomUUID(),
+            newProposalId: () => randomUUID(),
+        });
+        const actions = [];
+        for (const outcome of outcomes) {
+            const action = await persistCandidate(deps, outcome, vault);
+            if (action !== null) {
+                actions.push(action);
+            }
+        }
+        return actions;
+    }
+    catch (error) {
+        // Boundary: salience must never break the chat path. Log and continue.
+        // eslint-disable-next-line no-console
+        console.error("salience capture failed", redactedErrorMessage(error, deps));
+        return [];
+    }
+}

package/dist/memory-scope-sanitizer.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryAuditEvent, MemoryScope } from "@oscharko-dev/keiko-contracts";
+export declare function sanitizeMemoryScope(scope: MemoryScope, redactString: (input: string) => string): MemoryScope;
+export declare function memoryScopeKey(scope: MemoryScope): string;
+export declare function sanitizeAuditEvent(event: MemoryAuditEvent, redactString: (input: string) => string): MemoryAuditEvent;
+export declare function auditEventTouchesScope(event: MemoryAuditEvent, allowedScopeKeys: ReadonlySet<string>): boolean;
+//# sourceMappingURL=memory-scope-sanitizer.d.ts.map

package/dist/memory-scope-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-scope-sanitizer.d.ts","sourceRoot":"","sources":["../src/memory-scope-sanitizer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAenF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACtC,WAAW,CAgCb;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAiBzD;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACtC,gBAAgB,CA+BlB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,gBAAgB,EACvB,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GACpC,OAAO,CAYT"}

package/dist/memory-scope-sanitizer.js

@@ -0,0 +1,106 @@
+import { createHash } from "node:crypto";
+import { safeSummary } from "./memory-audit-event-builders.js";
+function maskedCoordinate(value, redactString) {
+    if (value.startsWith("[redacted:") && value.endsWith("]")) {
+        return value;
+    }
+    const redacted = redactString(value);
+    if (redacted !== value) {
+        return redacted;
+    }
+    const digest = createHash("sha256").update(value).digest("hex").slice(0, 12);
+    return `[redacted:${digest}]`;
+}
+export function sanitizeMemoryScope(scope, redactString) {
+    switch (scope.kind) {
+        case "user":
+            return {
+                kind: "user",
+                userId: maskedCoordinate(scope.userId, redactString),
+            };
+        case "workspace":
+            return {
+                kind: "workspace",
+                workspaceId: maskedCoordinate(scope.workspaceId, redactString),
+            };
+        case "project":
+            return {
+                kind: "project",
+                projectId: maskedCoordinate(scope.projectId, redactString),
+            };
+        case "workflow":
+            return {
+                kind: "workflow",
+                workflowDefinitionId: maskedCoordinate(scope.workflowDefinitionId, redactString),
+            };
+        case "global":
+            return { kind: "global" };
+        default: {
+            const never = scope;
+            return never;
+        }
+    }
+}
+export function memoryScopeKey(scope) {
+    switch (scope.kind) {
+        case "user":
+            return `user:${scope.userId}`;
+        case "workspace":
+            return `workspace:${scope.workspaceId}`;
+        case "project":
+            return `project:${scope.projectId}`;
+        case "workflow":
+            return `workflow:${scope.workflowDefinitionId}`;
+        case "global":
+            return "global";
+        default: {
+            const never = scope;
+            return never;
+        }
+    }
+}
+export function sanitizeAuditEvent(event, redactString) {
+    const redactedSummary = safeSummary(event.summary, redactString);
+    switch (event.kind) {
+        case "memory:retrieved":
+            return {
+                ...event,
+                summary: redactedSummary,
+                scopes: event.scopes.map((scope) => sanitizeMemoryScope(scope, redactString)),
+            };
+        case "memory:workflow-used":
+            return { ...event, summary: redactedSummary };
+        case "memory:workflow-omitted":
+            return {
+                ...event,
+                summary: redactedSummary,
+                reason: safeSummary(event.reason, redactString),
+                scopes: event.scopes.map((scope) => sanitizeMemoryScope(scope, redactString)),
+            };
+        case "memory:workflow-write-candidate":
+            return {
+                ...event,
+                summary: redactedSummary,
+                scope: sanitizeMemoryScope(event.scope, redactString),
+            };
+        default:
+            return {
+                ...event,
+                summary: redactedSummary,
+                scope: sanitizeMemoryScope(event.scope, redactString),
+            };
+    }
+}
+export function auditEventTouchesScope(event, allowedScopeKeys) {
+    switch (event.kind) {
+        case "memory:retrieved":
+        case "memory:workflow-omitted":
+            return event.scopes.some((scope) => allowedScopeKeys.has(memoryScopeKey(scope)));
+        case "memory:workflow-used":
+            return false;
+        case "memory:workflow-write-candidate":
+            return allowedScopeKeys.has(memoryScopeKey(event.scope));
+        default:
+            return allowedScopeKeys.has(memoryScopeKey(event.scope));
+    }
+}

package/dist/memory-target-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { CaptureMemoryResolver } from "@oscharko-dev/keiko-memory-capture";
+import type { MemoryVaultStore } from "@oscharko-dev/keiko-memory-vault";
+export declare function createMemoryTargetResolver(vault: MemoryVaultStore): CaptureMemoryResolver;
+//# sourceMappingURL=memory-target-resolver.d.ts.map

package/dist/memory-target-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-target-resolver.d.ts","sourceRoot":"","sources":["../src/memory-target-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AA+EzE,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,gBAAgB,GAAG,qBAAqB,CASzF"}

package/dist/memory-target-resolver.js

@@ -0,0 +1,73 @@
+const TARGETABLE_STATUSES = [
+    "accepted",
+    "archived",
+    "conflicted",
+    "expired",
+    "superseded",
+];
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "about",
+    "for",
+    "i",
+    "is",
+    "it",
+    "me",
+    "memory",
+    "my",
+    "of",
+    "please",
+    "that",
+    "the",
+    "this",
+    "to",
+    "we",
+]);
+function normalizePhrase(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function stemToken(token) {
+    const strippedPossessive = token.endsWith("'s") ? token.slice(0, -2) : token;
+    const suffixes = ["ence", "ance", "ing", "ers", "ies", "ied", "ed", "es", "s"];
+    for (const suffix of suffixes) {
+        if (strippedPossessive.length > suffix.length + 2 && strippedPossessive.endsWith(suffix)) {
+            return strippedPossessive.slice(0, -suffix.length);
+        }
+    }
+    return strippedPossessive;
+}
+function tokenize(value) {
+    return normalizePhrase(value)
+        .split(/\s+/)
+        .map(stemToken)
+        .filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+function tokensMatch(targetTokens, bodyTokens) {
+    if (targetTokens.length === 0) {
+        return false;
+    }
+    return targetTokens.every((target) => bodyTokens.some((body) => body === target || body.startsWith(target) || target.startsWith(body)));
+}
+function matchesTarget(target, record) {
+    const haystack = `${record.body} ${record.tags.join(" ")}`;
+    const normalizedTarget = normalizePhrase(target);
+    const normalizedHaystack = normalizePhrase(haystack);
+    if (normalizedTarget.length > 0 &&
+        (normalizedHaystack.includes(normalizedTarget) || normalizedTarget.includes(normalizedHaystack))) {
+        return true;
+    }
+    return tokensMatch(tokenize(target), tokenize(haystack));
+}
+export function createMemoryTargetResolver(vault) {
+    return (target, scope) => vault
+        .listMemoriesByScope(scope, {
+        status: TARGETABLE_STATUSES,
+        includeExpired: true,
+    })
+        .filter((record) => matchesTarget(target, record))
+        .map((record) => record.id);
+}

package/dist/memory-workflow-port.d.ts

@@ -0,0 +1,14 @@
+import type { MemoryWorkflowPort } from "@oscharko-dev/keiko-contracts";
+import type { MemoryVaultStore } from "@oscharko-dev/keiko-memory-vault";
+import type { EvidenceStore } from "@oscharko-dev/keiko-evidence";
+interface WorkflowMemoryPortOptions {
+    readonly vault: MemoryVaultStore;
+    readonly evidenceStore: EvidenceStore;
+    readonly runId: string;
+    readonly redactString: (input: string) => string;
+    readonly customerIdentifierMatchers?: readonly RegExp[] | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export declare function createWorkflowMemoryPort(options: WorkflowMemoryPortOptions): MemoryWorkflowPort;
+export {};
+//# sourceMappingURL=memory-workflow-port.d.ts.map

package/dist/memory-workflow-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-workflow-port.d.ts","sourceRoot":"","sources":["../src/memory-workflow-port.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAMV,kBAAkB,EAEnB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAOlE,UAAU,yBAAyB;IACjC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACjD,QAAQ,CAAC,0BAA0B,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACpE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AAoPD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAsB/F"}

package/dist/memory-workflow-port.js

@@ -0,0 +1,186 @@
+import { randomUUID } from "node:crypto";
+import { extractCandidatesFromWorkflowOutcome, } from "@oscharko-dev/keiko-memory-capture";
+import { retrieveMemoryContext } from "@oscharko-dev/keiko-memory-retrieval";
+import { recordMemoryAudit, recordMemoryAudits } from "./memory-audit-handler.js";
+import { vaultAsQueryPort } from "./memory-conv-handlers.js";
+import { LOCAL_CONVERSATION_MEMORY_USER_ID } from "./memory-conversation-context.js";
+import { buildMemoryRecordFromProposal } from "./memory-record-builders.js";
+import { isPersistableMemoryCandidate } from "./memory-capture-policy.js";
+function buildRetrievedAudit(occurredAt, scopes, matchedMemoryIds) {
+    if (matchedMemoryIds.length === 0) {
+        return undefined;
+    }
+    return {
+        schemaVersion: "1",
+        kind: "memory:retrieved",
+        eventId: randomUUID(),
+        occurredAt,
+        initiatorSurface: "workflow",
+        summary: matchedMemoryIds.length === 1
+            ? "Retrieved 1 memory for workflow context."
+            : `Retrieved ${String(matchedMemoryIds.length)} memories for workflow context.`,
+        scopes,
+        matchedMemoryIds,
+    };
+}
+function buildWorkflowOmittedAudit(options, occurredAt, event) {
+    return {
+        schemaVersion: "1",
+        kind: "memory:workflow-omitted",
+        eventId: randomUUID(),
+        occurredAt,
+        initiatorSurface: "workflow",
+        summary: `Workflow omitted memory (${event.reason}).`,
+        workflowRunId: options.runId,
+        scopes: event.scopes,
+        omittedMemoryId: event.memoryId,
+        reason: event.reason,
+    };
+}
+function recordWorkflowOmittedAudit(options, now, event) {
+    recordMemoryAudit({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, buildWorkflowOmittedAudit(options, now(), event));
+}
+function recordWorkflowRetrievalAudits(options, now, scopes, matchedMemoryIds, omittedMemories) {
+    const occurredAt = now();
+    const events = [];
+    const retrievedEvent = buildRetrievedAudit(occurredAt, scopes, matchedMemoryIds);
+    if (retrievedEvent !== undefined) {
+        events.push(retrievedEvent);
+    }
+    for (const omitted of omittedMemories) {
+        events.push(buildWorkflowOmittedAudit(options, occurredAt, {
+            memoryId: omitted.memoryId,
+            reason: omitted.reason,
+            scopes,
+        }));
+    }
+    recordMemoryAudits({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, events);
+}
+function recordWorkflowUsedAudit(options, now, event) {
+    recordMemoryAudit({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, {
+        schemaVersion: "1",
+        kind: "memory:workflow-used",
+        eventId: randomUUID(),
+        occurredAt: now(),
+        initiatorSurface: "workflow",
+        summary: event.memoryIds.length === 1
+            ? `Workflow used 1 memory (${event.reason}).`
+            : `Workflow used ${String(event.memoryIds.length)} memories (${event.reason}).`,
+        workflowRunId: options.runId,
+        usedMemoryIds: event.memoryIds,
+    });
+}
+function recordWorkflowWriteCandidateAudit(options, now, event, proposedMemoryIds) {
+    const auditEvent = {
+        schemaVersion: "1",
+        kind: "memory:workflow-write-candidate",
+        eventId: randomUUID(),
+        occurredAt: now(),
+        initiatorSurface: "workflow",
+        summary: proposedMemoryIds.length === 0
+            ? `Workflow produced a memory write candidate that was not eligible for review (${event.source}).`
+            : proposedMemoryIds.length === 1
+                ? `Workflow produced 1 governed memory write candidate (${event.source}).`
+                : `Workflow produced ${String(proposedMemoryIds.length)} governed memory write candidates (${event.source}).`,
+        workflowRunId: options.runId,
+        source: event.source,
+        scope: event.scope,
+        proposedMemoryIds,
+    };
+    recordMemoryAudit({
+        evidenceStore: options.evidenceStore,
+        redactString: options.redactString,
+        now,
+    }, auditEvent);
+}
+function persistWorkflowCandidates(options, event, capturedAt) {
+    const outcomes = extractCandidatesFromWorkflowOutcome({
+        runId: options.runId,
+        outcomeKind: event.source === "workflow-correction" ? "corrected" : "success",
+        structuredReport: event.proposalSummary,
+        capturedAt,
+    }, captureContextFor(event.scope, capturedAt, options.runId), {
+        scopeKind: event.scope.kind,
+        ...(options.customerIdentifierMatchers === undefined
+            ? {}
+            : { customerIdentifierMatchers: options.customerIdentifierMatchers }),
+    });
+    const proposedMemoryIds = [];
+    for (const outcome of outcomes) {
+        if (!isPersistableMemoryCandidate(outcome)) {
+            continue;
+        }
+        const proposalId = outcome.proposal.proposalId;
+        const record = buildMemoryRecordFromProposal(proposalId, outcome);
+        if (record !== null) {
+            options.vault.insertMemory(record);
+            proposedMemoryIds.push(record.id);
+        }
+    }
+    return proposedMemoryIds;
+}
+function captureContextFor(scope, nowMs, runId) {
+    return {
+        userId: LOCAL_CONVERSATION_MEMORY_USER_ID,
+        ...(scope.kind === "workspace" ? { workspaceId: scope.workspaceId } : {}),
+        ...(scope.kind === "project" ? { projectId: scope.projectId } : {}),
+        sourceWorkflowRunId: runId,
+        ...(scope.kind === "workflow"
+            ? {
+                workflowDefinitionId: scope.workflowDefinitionId,
+            }
+            : {}),
+        nowMs,
+        newMemoryId: () => randomUUID(),
+        newProposalId: () => randomUUID(),
+    };
+}
+function createWorkflowContextGetter(options, now, queryPort) {
+    return (scopes, queryText, budgetTokens) => {
+        const result = retrieveMemoryContext({
+            scopes,
+            nowMs: now(),
+            ...(queryText === undefined ? {} : { queryText }),
+            ...(budgetTokens === undefined ? {} : { budgetTokens }),
+        }, queryPort);
+        recordWorkflowRetrievalAudits(options, now, scopes, result.included.map((item) => item.memoryId), result.omitted);
+        return Promise.resolve({
+            text: result.contextBlock.text,
+            includedMemoryIds: result.contextBlock.memories.map((item) => item.memoryId),
+        });
+    };
+}
+export function createWorkflowMemoryPort(options) {
+    const now = options.now ?? Date.now;
+    const queryPort = vaultAsQueryPort(options.vault);
+    return {
+        getContextForWorkflow: createWorkflowContextGetter(options, now, queryPort),
+        onMemoryUsed(event) {
+            recordWorkflowUsedAudit(options, now, event);
+        },
+        onMemoryOmitted(event) {
+            recordWorkflowOmittedAudit(options, now, {
+                memoryId: event.memoryId,
+                reason: event.reason,
+                scopes: [],
+            });
+        },
+        onMemoryWriteCandidate(event) {
+            const capturedAt = now();
+            const proposedMemoryIds = persistWorkflowCandidates(options, event, capturedAt);
+            recordWorkflowWriteCandidateAudit(options, () => capturedAt, event, proposedMemoryIds);
+        },
+    };
+}

package/dist/private-json.d.ts

@@ -0,0 +1,3 @@
+export declare function savePrivateJson(path: string, raw: Record<string, unknown>): void;
+export declare function assertNoSymlinkedPathSegments(resolvedPath: string): void;
+//# sourceMappingURL=private-json.d.ts.map

package/dist/private-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private-json.d.ts","sourceRoot":"","sources":["../src/private-json.ts"],"names":[],"mappings":"AAoBA,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAgChF;AAED,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAQxE"}

package/dist/private-json.js

@@ -0,0 +1,62 @@
+// Atomic, private-permission JSON writer for local runtime files (keiko.config.json and siblings).
+//
+// Extracted from gateway-setup so the first-run setup writer and the one-time credential migration
+// share ONE crash-safe write path (Issue #1320): a fresh temp file in the same directory is written
+// with 0600, then renamed over the target so a reader never observes a partially written file. Every
+// path segment is checked for symlinks first so a hostile symlink cannot redirect the write outside
+// the intended private directory.
+import { chmodSync, existsSync, lstatSync, mkdirSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+export function savePrivateJson(path, raw) {
+    const resolvedPath = resolve(path);
+    const dir = dirname(resolvedPath);
+    assertNoSymlinkedPathSegments(resolvedPath);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    assertNoSymlinkedPathSegments(resolvedPath);
+    if (process.platform !== "win32") {
+        chmodSync(dir, 0o700);
+    }
+    const tempPath = join(dir, `.keiko-config.${String(process.pid)}.${Date.now().toString(36)}.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(tempPath, `${JSON.stringify(raw, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        if (process.platform !== "win32") {
+            chmodSync(tempPath, 0o600);
+        }
+        renameSync(tempPath, resolvedPath);
+    }
+    finally {
+        if (existsSync(tempPath)) {
+            try {
+                unlinkSync(tempPath);
+            }
+            catch {
+                // Best-effort cleanup only.
+            }
+        }
+    }
+}
+export function assertNoSymlinkedPathSegments(resolvedPath) {
+    let current = resolvedPath;
+    while (current !== dirname(current)) {
+        if (isSymlink(current)) {
+            throw new Error("refusing to write gateway config through a symlinked path");
+        }
+        current = dirname(current);
+    }
+}
+function isSymlink(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/promptEnhancer/index.d.ts

@@ -0,0 +1,3 @@
+export { handlePromptEnhancement, handlePromptEnhancementEvidence } from "./routes.js";
+export { PromptEnhancementCancelledError, PromptEnhancementInputError, buildPromptEnhancementRecordInput, runPromptEnhancement, type RunPromptEnhancementDeps, } from "./orchestrate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/promptEnhancer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,uBAAuB,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,EACL,+BAA+B,EAC/B,2BAA2B,EAC3B,iCAAiC,EACjC,oBAAoB,EACpB,KAAK,wBAAwB,GAC9B,MAAM,kBAAkB,CAAC"}

package/dist/promptEnhancer/index.js

@@ -0,0 +1,5 @@
+// Public barrel for the Prompt Enhancer server sub-module (Epic #1307, Issue #1314; ADR-0044 §1).
+// Exposes the BFF route handler and the reusable, deterministic orchestration the CLI surface also
+// drives (so both surfaces produce byte-identical enhancements — AC1).
+export { handlePromptEnhancement, handlePromptEnhancementEvidence } from "./routes.js";
+export { PromptEnhancementCancelledError, PromptEnhancementInputError, buildPromptEnhancementRecordInput, runPromptEnhancement, } from "./orchestrate.js";

package/dist/promptEnhancer/orchestrate.d.ts

@@ -0,0 +1,2 @@
+export { PromptEnhancementCancelledError, PromptEnhancementInputError, buildPromptEnhancementRecordInput, promptEnhancementGatewayRoutingConfig, runPromptEnhancement, type PromptEnhancementGatewayRoutingConfig, type RunPromptEnhancementDeps, } from "@oscharko-dev/keiko-workflows";
+//# sourceMappingURL=orchestrate.d.ts.map

package/dist/promptEnhancer/orchestrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrate.d.ts","sourceRoot":"","sources":["../../src/promptEnhancer/orchestrate.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,+BAA+B,EAC/B,2BAA2B,EAC3B,iCAAiC,EACjC,qCAAqC,EACrC,oBAAoB,EACpB,KAAK,qCAAqC,EAC1C,KAAK,wBAAwB,GAC9B,MAAM,+BAA+B,CAAC"}

package/dist/promptEnhancer/orchestrate.js

@@ -0,0 +1,5 @@
+// Compatibility barrel for the Prompt Enhancer workflow authority.
+//
+// The lifecycle lives in `@oscharko-dev/keiko-workflows/promptEnhancer` per ADR-0044; server callers
+// keep importing from this path so existing route and public server exports stay stable.
+export { PromptEnhancementCancelledError, PromptEnhancementInputError, buildPromptEnhancementRecordInput, promptEnhancementGatewayRoutingConfig, runPromptEnhancement, } from "@oscharko-dev/keiko-workflows";