@oscharko-dev/keiko-server 0.2.0

package/dist/governed-workflow.d.ts

@@ -0,0 +1,17 @@
+import type { EvidenceGovernedWorkflowHandoff } from "@oscharko-dev/keiko-contracts/evidence";
+import type { ConnectedContextPack } from "@oscharko-dev/keiko-contracts/connected-context";
+import { type ProposedPatchEntry, type UserApprovalTokenInput, type WorkflowHandoffRequest } from "@oscharko-dev/keiko-contracts/workflow-handoff";
+import type { PatchValidation, WorkspaceWriter } from "@oscharko-dev/keiko-tools";
+export interface GovernedWorkflowHandoffContext {
+    readonly request: WorkflowHandoffRequest;
+    readonly sourceGroundedRunId?: string | undefined;
+}
+export declare function contextPackStableIdForPacks(packs: readonly ConnectedContextPack[]): string;
+export declare function readOnlyPathsForPacks(packs: readonly ConnectedContextPack[], editablePaths: readonly string[]): readonly string[];
+export declare function evidenceAtomIdsForPacks(packs: readonly ConnectedContextPack[]): readonly string[];
+export declare function approvalTokenInputFor(request: WorkflowHandoffRequest): UserApprovalTokenInput;
+export declare function createApprovalToken(input: UserApprovalTokenInput): string;
+export declare function buildGovernedHandoffEvidence(handoff: GovernedWorkflowHandoffContext): EvidenceGovernedWorkflowHandoff;
+export declare function createScopedWriter(baseWriter: WorkspaceWriter, workspaceRoot: string, editablePaths: readonly string[]): WorkspaceWriter;
+export declare function proposedPatchEntriesFromValidation(validation: PatchValidation): readonly ProposedPatchEntry[];
+//# sourceMappingURL=governed-workflow.d.ts.map

package/dist/governed-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governed-workflow.d.ts","sourceRoot":"","sources":["../src/governed-workflow.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;AAC5F,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,gDAAgD,CAAC;AACxD,OAAO,KAAK,EAAmB,eAAe,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGnG,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;IACzC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnD;AAkDD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,GAAG,MAAM,CAS1F;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,oBAAoB,EAAE,EACtC,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,SAAS,MAAM,EAAE,CAWnB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,MAAM,EAAE,CAUjG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,sBAAsB,CAW7F;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAEzE;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,8BAA8B,GACtC,+BAA+B,CAWjC;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,eAAe,EAC3B,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,eAAe,CA4BjB;AAED,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,eAAe,GAC1B,SAAS,kBAAkB,EAAE,CAkB/B"}

package/dist/governed-workflow.js

@@ -0,0 +1,147 @@
+import { createHash } from "node:crypto";
+import { sep } from "node:path";
+import { EXPECTED_CHECKS, } from "@oscharko-dev/keiko-contracts/workflow-handoff";
+import { resolveWithinWorkspace } from "@oscharko-dev/keiko-workspace";
+function sha256Hex(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function sortChecks(checks) {
+    const order = new Map(EXPECTED_CHECKS.map((check, index) => [check, index]));
+    return [...checks].sort((a, b) => (order.get(a) ?? 999) - (order.get(b) ?? 999) || a.localeCompare(b));
+}
+function fileHeader(file) {
+    if (file.kind === "create") {
+        return ["--- /dev/null", `+++ b/${file.path}`];
+    }
+    if (file.kind === "delete") {
+        return [`--- a/${file.path}`, "+++ /dev/null"];
+    }
+    return [`--- a/${file.path}`, `+++ b/${file.path}`];
+}
+function filePatchBytes(file) {
+    const lines = [...fileHeader(file)];
+    for (const hunk of file.hunks) {
+        lines.push(`@@ -${String(hunk.oldStart)},${String(hunk.oldLines)} +${String(hunk.newStart)},${String(hunk.newLines)} @@`);
+        lines.push(...hunk.lines);
+    }
+    return Buffer.byteLength(lines.join("\n"), "utf8");
+}
+function absoluteEditablePaths(workspaceRoot, editablePaths) {
+    return new Set(editablePaths.map((path) => resolveWithinWorkspace(workspaceRoot, path)));
+}
+function canCreateDirectory(dir, allowedFiles) {
+    for (const allowed of allowedFiles) {
+        if (allowed === dir || allowed.startsWith(`${dir}${sep}`)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function contextPackStableIdForPacks(packs) {
+    if (packs.length === 1) {
+        return packs[0]?.stableId ?? `p-${"0".repeat(64)}`;
+    }
+    const joined = packs
+        .map((pack) => pack.stableId)
+        .sort()
+        .join("|");
+    return `p-${sha256Hex(joined)}`;
+}
+export function readOnlyPathsForPacks(packs, editablePaths) {
+    const editable = new Set(editablePaths);
+    const unique = new Set();
+    for (const pack of packs) {
+        for (const file of pack.files) {
+            if (!editable.has(file.scopePath)) {
+                unique.add(file.scopePath);
+            }
+        }
+    }
+    return [...unique].sort();
+}
+export function evidenceAtomIdsForPacks(packs) {
+    const unique = new Set();
+    for (const pack of packs) {
+        for (const file of pack.files) {
+            for (const excerpt of file.excerpts) {
+                unique.add(excerpt.atom.stableId);
+            }
+        }
+    }
+    return [...unique].sort();
+}
+export function approvalTokenInputFor(request) {
+    return {
+        contextPackStableId: request.contextPackStableId,
+        workflowKind: request.workflowKind,
+        editablePaths: [...request.patchScope.editablePaths].sort(),
+        readOnlyPaths: [...request.patchScope.readOnlyPaths].sort(),
+        evidenceAtomIds: [...request.patchScope.evidenceAtomIds].sort(),
+        limits: request.patchScope.limits,
+        expectedChecks: sortChecks(request.patchScope.expectedChecks),
+        unknowns: [...request.patchScope.unknowns].sort(),
+    };
+}
+export function createApprovalToken(input) {
+    return sha256Hex(JSON.stringify(input));
+}
+export function buildGovernedHandoffEvidence(handoff) {
+    return {
+        sourceGroundedRunId: handoff.sourceGroundedRunId ?? "unavailable",
+        contextPackStableIdHash: sha256Hex(handoff.request.contextPackStableId),
+        workflowKind: handoff.request.workflowKind,
+        editablePathCount: handoff.request.patchScope.editablePaths.length,
+        readOnlyPathCount: handoff.request.patchScope.readOnlyPaths.length,
+        evidenceAtomCount: handoff.request.patchScope.evidenceAtomIds.length,
+        expectedChecks: [...handoff.request.patchScope.expectedChecks],
+        approvalTokenHash: sha256Hex(handoff.request.userApprovalToken),
+    };
+}
+export function createScopedWriter(baseWriter, workspaceRoot, editablePaths) {
+    const allowedFiles = absoluteEditablePaths(workspaceRoot, editablePaths);
+    const assertAllowed = (absolutePath) => {
+        if (!allowedFiles.has(absolutePath)) {
+            throw new Error(`Patch scope forbids writing ${absolutePath}`);
+        }
+    };
+    return {
+        writeFileUtf8(absolutePath, content) {
+            assertAllowed(absolutePath);
+            baseWriter.writeFileUtf8(absolutePath, content);
+        },
+        mkdirp(absoluteDir) {
+            if (!canCreateDirectory(absoluteDir, allowedFiles)) {
+                throw new Error(`Patch scope forbids creating ${absoluteDir}`);
+            }
+            baseWriter.mkdirp(absoluteDir);
+        },
+        remove(absolutePath) {
+            assertAllowed(absolutePath);
+            baseWriter.remove(absolutePath);
+        },
+        rename(fromAbsolute, toAbsolute) {
+            assertAllowed(fromAbsolute);
+            assertAllowed(toAbsolute);
+            baseWriter.rename(fromAbsolute, toAbsolute);
+        },
+    };
+}
+export function proposedPatchEntriesFromValidation(validation) {
+    if (validation.files.length === 0) {
+        return [];
+    }
+    const entries = validation.files.map((file) => ({
+        path: file.path,
+        newFile: file.kind === "create",
+        patchBytes: filePatchBytes(file),
+    }));
+    const observed = entries.reduce((sum, entry) => sum + entry.patchBytes, 0);
+    const delta = Math.max(0, validation.totalBytes - observed);
+    if (delta > 0) {
+        const last = entries[entries.length - 1];
+        if (last !== undefined) {
+            last.patchBytes += delta;
+        }
+    }
+    return entries;
+}

package/dist/grounded-answer.d.ts

@@ -0,0 +1,12 @@
+export interface GroundedAnswerUsage {
+    readonly promptTokens: number;
+    readonly completionTokens: number;
+}
+export interface GroundedAnswerResult {
+    readonly content: string;
+    readonly usage: GroundedAnswerUsage;
+}
+export type GroundedAnswerPayload = string | GroundedAnswerResult;
+export declare function sanitizeGroundedAnswerContent(content: string): string;
+export declare function normalizeGroundedAnswerPayload(payload: GroundedAnswerPayload): GroundedAnswerResult;
+//# sourceMappingURL=grounded-answer.d.ts.map

package/dist/grounded-answer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounded-answer.d.ts","sourceRoot":"","sources":["../src/grounded-answer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;CACrC;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AA2DlE,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CASrE;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CAgBtB"}

package/dist/grounded-answer.js

@@ -0,0 +1,69 @@
+const SAFE_GROUNDED_FALLBACK = "I could not produce a clean grounded answer from the retrieved repository evidence.";
+const ORCHESTRATION_PREFIX_RE = /^(searching for\b|search query\b|we need to call search\b|let'?s search\b|calling search\b|tool call\b|plan\b:|system prompt\b:|developer prompt\b:|internal planning\b:|internal reasoning\b:|hidden instruction\b:)/i;
+const PROMPT_DISCLOSURE_RE = /^(system prompt\b:|developer prompt\b:|internal planning\b:|internal reasoning\b:|hidden instruction\b:)/i;
+const ARGUMENT_LINE_RE = /^(?:[{[]|["']?(?:path|query|max_results|maxResults|tool|arguments|scope|search)["']?\s*:)/i;
+function isFiniteCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isOrchestrationLine(line) {
+    return ORCHESTRATION_PREFIX_RE.test(line);
+}
+function isArgumentLine(line) {
+    if (ARGUMENT_LINE_RE.test(line)) {
+        return true;
+    }
+    return line === "}" || line === "]" || line === "}," || line === "],";
+}
+function shouldStripLeadingLine(trimmed, stripping) {
+    if (trimmed.length === 0) {
+        return true;
+    }
+    if (!stripping) {
+        return isOrchestrationLine(trimmed);
+    }
+    return (isOrchestrationLine(trimmed) ||
+        isArgumentLine(trimmed) ||
+        trimmed.startsWith("{") ||
+        trimmed.startsWith("["));
+}
+function leadingContentIndex(lines) {
+    let index = 0;
+    let stripping = false;
+    while (index < lines.length) {
+        const trimmed = lines[index]?.trim() ?? "";
+        const shouldStrip = shouldStripLeadingLine(trimmed, stripping);
+        if (!shouldStrip) {
+            return index;
+        }
+        stripping ||= isOrchestrationLine(trimmed);
+        index += 1;
+    }
+    return index;
+}
+export function sanitizeGroundedAnswerContent(content) {
+    const lines = content.split("\n");
+    const index = leadingContentIndex(lines);
+    const sanitized = lines
+        .slice(index)
+        .filter((line) => !PROMPT_DISCLOSURE_RE.test(line.trim()))
+        .join("\n")
+        .trim();
+    return sanitized.length > 0 ? sanitized : SAFE_GROUNDED_FALLBACK;
+}
+export function normalizeGroundedAnswerPayload(payload) {
+    if (typeof payload === "string") {
+        return {
+            content: sanitizeGroundedAnswerContent(payload.trim()),
+            usage: { promptTokens: 0, completionTokens: 0 },
+        };
+    }
+    return {
+        content: sanitizeGroundedAnswerContent(payload.content.trim()),
+        usage: {
+            promptTokens: isFiniteCount(payload.usage.promptTokens) ? payload.usage.promptTokens : 0,
+            completionTokens: isFiniteCount(payload.usage.completionTokens)
+                ? payload.usage.completionTokens
+                : 0,
+        },
+    };
+}

package/dist/grounded-context-index.d.ts

@@ -0,0 +1,25 @@
+import type { SelectedScope } from "@oscharko-dev/keiko-contracts/connected-context";
+import { type MicroIndex } from "@oscharko-dev/keiko-workflows";
+export interface GroundedContextIndexRegistryOptions {
+    readonly ttlMs?: number;
+    readonly maxEntriesPerScope?: number;
+    readonly maxScopes?: number;
+    readonly sweepIntervalMs?: number;
+    readonly autoSweep?: boolean;
+}
+export interface GroundedContextIndexRegistry {
+    forScope(scope: SelectedScope, nowMs: () => number): MicroIndex;
+    clearConversation(conversationId: string): void;
+    clearWorkspace(workspaceRoot: string): void;
+    clearAll(): void;
+    sweep(nowMs: () => number): void;
+    size(): number;
+    dispose(): void;
+}
+export declare function createGroundedContextIndexRegistry(options?: GroundedContextIndexRegistryOptions): GroundedContextIndexRegistry;
+export declare const groundedContextIndexRegistry: GroundedContextIndexRegistry;
+export declare function microIndexForGroundedScope(scope: SelectedScope, nowMs: () => number): MicroIndex;
+export declare function clearGroundedContextIndexesForConversation(conversationId: string): void;
+export declare function clearGroundedContextIndexesForWorkspace(workspaceRoot: string): void;
+export declare function clearAllGroundedContextIndexes(): void;
+//# sourceMappingURL=grounded-context-index.d.ts.map

package/dist/grounded-context-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounded-context-index.d.ts","sourceRoot":"","sources":["../src/grounded-context-index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,UAAU,CAAC;IAChE,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,IAAI,IAAI,CAAC;IACjB,KAAK,CAAC,KAAK,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACjC,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;CACjB;AAmKD,wBAAgB,kCAAkC,CAChD,OAAO,CAAC,EAAE,mCAAmC,GAC5C,4BAA4B,CAsC9B;AAED,eAAO,MAAM,4BAA4B,8BAAuC,CAAC;AAEjF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,UAAU,CAEhG;AAED,wBAAgB,0CAA0C,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAEvF;AAED,wBAAgB,uCAAuC,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAEnF;AAED,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/grounded-context-index.js

@@ -0,0 +1,169 @@
+// Server-local lifecycle for Issue #183's ephemeral context-pack micro-index. The workflow
+// package owns the cache implementation; this module scopes instances to a connected chat/session
+// and provides deterministic cleanup hooks for chat/project lifecycle changes. Nothing persists.
+import { createHash } from "node:crypto";
+import { createMicroIndex, DEFAULT_MICRO_INDEX, } from "@oscharko-dev/keiko-workflows";
+const DEFAULT_MAX_SCOPES = 32;
+const DEFAULT_MAX_ENTRIES_PER_SCOPE = 8;
+const DEFAULT_SWEEP_INTERVAL_MS = 60_000;
+function assertPositiveInteger(name, value) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive integer`);
+    }
+}
+function optionOrDefault(value, fallback) {
+    return value ?? fallback;
+}
+function resolveOptions(options) {
+    const provided = options ?? {};
+    const resolved = {
+        ttlMs: optionOrDefault(provided.ttlMs, DEFAULT_MICRO_INDEX.ttlMs),
+        maxEntriesPerScope: optionOrDefault(provided.maxEntriesPerScope, DEFAULT_MAX_ENTRIES_PER_SCOPE),
+        maxScopes: optionOrDefault(provided.maxScopes, DEFAULT_MAX_SCOPES),
+        sweepIntervalMs: optionOrDefault(provided.sweepIntervalMs, DEFAULT_SWEEP_INTERVAL_MS),
+        autoSweep: optionOrDefault(provided.autoSweep, true),
+    };
+    assertPositiveInteger("ttlMs", resolved.ttlMs);
+    assertPositiveInteger("maxEntriesPerScope", resolved.maxEntriesPerScope);
+    assertPositiveInteger("maxScopes", resolved.maxScopes);
+    assertPositiveInteger("sweepIntervalMs", resolved.sweepIntervalMs);
+    return resolved;
+}
+function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function scopeKey(scope) {
+    const source = JSON.stringify({
+        workspaceRoot: scope.workspaceRoot,
+        scopeId: scope.scopeId,
+        kind: scope.kind,
+        relativePaths: [...scope.relativePaths].sort(),
+        conversationId: scope.conversationId,
+        connectedAtMs: scope.connectedAtMs,
+    });
+    return `gci-${sha256Hex(source).slice(0, 16)}`;
+}
+function evictExpired(entries, nowMs) {
+    for (const [key, entry] of entries) {
+        if (entry.expiresAtMs <= nowMs) {
+            entry.index.clear();
+            entries.delete(key);
+        }
+    }
+}
+function evictOldest(entries, maxScopes) {
+    while (entries.size >= maxScopes) {
+        let oldest;
+        for (const entry of entries.values()) {
+            if (oldest === undefined || entry.touchedAtMs < oldest.touchedAtMs) {
+                oldest = entry;
+            }
+        }
+        if (oldest === undefined) {
+            return;
+        }
+        oldest.index.clear();
+        entries.delete(oldest.key);
+    }
+}
+function createEntry(key, scope, nowMs, options) {
+    const clock = { nowMs };
+    const now = nowMs();
+    return {
+        key,
+        index: createMicroIndex({
+            ttlMs: options.ttlMs,
+            maxEntries: options.maxEntriesPerScope,
+            nowMs: () => clock.nowMs(),
+        }),
+        clock,
+        conversationId: scope.conversationId,
+        workspaceRoot: scope.workspaceRoot,
+        touchedAtMs: now,
+        expiresAtMs: now + options.ttlMs,
+    };
+}
+function touchEntry(entry, nowMs, ttlMs) {
+    const now = nowMs();
+    entry.clock.nowMs = nowMs;
+    entry.touchedAtMs = now;
+    entry.expiresAtMs = now + ttlMs;
+}
+function getOrCreateScopeIndex(entries, options, scope, nowMs) {
+    evictExpired(entries, nowMs());
+    const key = scopeKey(scope);
+    const existing = entries.get(key);
+    if (existing !== undefined) {
+        touchEntry(existing, nowMs, options.ttlMs);
+        return existing.index;
+    }
+    evictOldest(entries, options.maxScopes);
+    const created = createEntry(key, scope, nowMs, options);
+    entries.set(key, created);
+    return created.index;
+}
+function clearMatching(entries, predicate) {
+    for (const [key, entry] of entries) {
+        if (predicate(entry)) {
+            entry.index.clear();
+            entries.delete(key);
+        }
+    }
+}
+function clearEntries(entries) {
+    for (const entry of entries.values()) {
+        entry.index.clear();
+    }
+    entries.clear();
+}
+export function createGroundedContextIndexRegistry(options) {
+    const resolved = resolveOptions(options);
+    const entries = new Map();
+    const sweepTimer = resolved.autoSweep
+        ? setInterval(() => {
+            evictExpired(entries, Date.now());
+        }, resolved.sweepIntervalMs)
+        : undefined;
+    if (sweepTimer !== undefined) {
+        sweepTimer.unref();
+    }
+    return {
+        forScope(scope, nowMs) {
+            return getOrCreateScopeIndex(entries, resolved, scope, nowMs);
+        },
+        clearConversation(conversationId) {
+            clearMatching(entries, (entry) => entry.conversationId === conversationId);
+        },
+        clearWorkspace(workspaceRoot) {
+            clearMatching(entries, (entry) => entry.workspaceRoot === workspaceRoot);
+        },
+        clearAll() {
+            clearEntries(entries);
+        },
+        sweep(nowMs) {
+            evictExpired(entries, nowMs());
+        },
+        size() {
+            return entries.size;
+        },
+        dispose() {
+            if (sweepTimer !== undefined) {
+                clearInterval(sweepTimer);
+            }
+            clearEntries(entries);
+        },
+    };
+}
+export const groundedContextIndexRegistry = createGroundedContextIndexRegistry();
+export function microIndexForGroundedScope(scope, nowMs) {
+    return groundedContextIndexRegistry.forScope(scope, nowMs);
+}
+export function clearGroundedContextIndexesForConversation(conversationId) {
+    groundedContextIndexRegistry.clearConversation(conversationId);
+}
+export function clearGroundedContextIndexesForWorkspace(workspaceRoot) {
+    groundedContextIndexRegistry.clearWorkspace(workspaceRoot);
+}
+export function clearAllGroundedContextIndexes() {
+    groundedContextIndexRegistry.clearAll();
+}

package/dist/grounded-document-evidence.d.ts

@@ -0,0 +1,28 @@
+import { type CandidateFile, type EvidenceAtom, type OmittedContextEntry, type RetrievalQuery, type SelectedScope, type UncertaintyMarker } from "@oscharko-dev/keiko-contracts/connected-context";
+import { type SearchScope, type WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+import type { ExcerptWindow } from "@oscharko-dev/keiko-workflows";
+export declare const MAX_DOCUMENT_INPUT_BYTES: number;
+export declare const MAX_DOCUMENT_EXTRACTED_BYTES: number;
+export declare const MAX_TOTAL_DOCUMENT_EXTRACTED_BYTES: number;
+export declare const MAX_DOCUMENT_WINDOW_BYTES: number;
+export declare const MAX_DOCUMENT_WINDOWS = 8;
+export declare const DOCUMENT_PARSE_TIMEOUT_MS = 5000;
+export declare const MAX_DOCUMENT_PARSE_UNITS = 5000;
+export declare function isConnectedDocumentPath(scopePath: string): boolean;
+export interface DocumentEvidenceInputs {
+    readonly scope: SelectedScope;
+    readonly query: RetrievalQuery;
+    readonly searchScope: SearchScope;
+    readonly fs: WorkspaceFs;
+    readonly nowMs: () => number;
+    readonly signal?: AbortSignal | undefined;
+}
+export interface DocumentEvidenceResult {
+    readonly atoms: readonly EvidenceAtom[];
+    readonly candidates: readonly CandidateFile[];
+    readonly excerpts: ReadonlyMap<string, readonly ExcerptWindow[]>;
+    readonly omitted: readonly OmittedContextEntry[];
+    readonly uncertainty: readonly UncertaintyMarker[];
+}
+export declare function collectConnectedDocumentEvidence(inputs: DocumentEvidenceInputs): Promise<DocumentEvidenceResult>;
+//# sourceMappingURL=grounded-document-evidence.d.ts.map

package/dist/grounded-document-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounded-document-evidence.d.ts","sourceRoot":"","sources":["../src/grounded-document-evidence.ts"],"names":[],"mappings":"AAyBA,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,iDAAiD,CAAC;AAGzD,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAInE,eAAO,MAAM,wBAAwB,QAAkB,CAAC;AACxD,eAAO,MAAM,4BAA4B,QAAY,CAAC;AACtD,eAAO,MAAM,kCAAkC,QAAY,CAAC;AAC5D,eAAO,MAAM,yBAAyB,QAAW,CAAC;AAClD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAC/C,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AA6E9C,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAGlE;AAID,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAC3C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC,CAAC;IACjE,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACpD;AA8YD,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,sBAAsB,CAAC,CAiCjC"}