@hassangameryt/freeflow 0.2.0 → 0.4.0

package/plugins/freeflow/router/dist/schema.js

@@ -1,354 +0,0 @@
-import { EXECUTION_STATUSES, EVIDENCE_WINDOWS, OUTPUT_STREAMS, PRESERVE_MODES, RETRIEVAL_ACTIONS, ROUTE_KINDS, ROUTING_STATUSES, TOOL_STATUSES, } from "./types.js";
-import { isValidPostToolRoutingMode, validateNormalizedRouterHints, validatePositiveIntegerThreshold, validateVaultRetentionPolicy, } from "./router-contract.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function success(value) {
-    return { ok: true, value };
-}
-function failure(issues) {
-    return { ok: false, issues };
-}
-function isOneOf(value, allowed) {
-    return typeof value === "string" && allowed.includes(value);
-}
-function requireString(record, key, path, issues) {
-    if (typeof record[key] !== "string" || record[key] === "") {
-        issues.push({ path: `${path}.${key}`, message: "Expected a non-empty string." });
-    }
-}
-function requireBoolean(record, key, path, issues) {
-    if (typeof record[key] !== "boolean") {
-        issues.push({ path: `${path}.${key}`, message: "Expected a boolean." });
-    }
-}
-function requireNonNegativeNumber(record, key, path, issues) {
-    if (typeof record[key] !== "number" || !Number.isFinite(record[key]) || record[key] < 0) {
-        issues.push({ path: `${path}.${key}`, message: "Expected a non-negative finite number." });
-    }
-}
-function requireInteger(record, key, path, issues) {
-    if (!Number.isInteger(record[key])) {
-        issues.push({ path: `${path}.${key}`, message: "Expected an integer." });
-    }
-}
-function requireNullableInteger(record, key, path, issues) {
-    if (record[key] !== null && !Number.isInteger(record[key])) {
-        issues.push({ path: `${path}.${key}`, message: "Expected an integer or null." });
-    }
-}
-function validateSourceRef(value, path, issues) {
-    if (!isRecord(value)) {
-        issues.push({ path, message: "Expected a source object." });
-        return;
-    }
-    if (value.kind === "repo") {
-        requireString(value, "path", path, issues);
-        return;
-    }
-    if (value.kind === "vault") {
-        requireString(value, "outputId", path, issues);
-        if (value.stream !== undefined && !isOneOf(value.stream, OUTPUT_STREAMS)) {
-            issues.push({ path: `${path}.stream`, message: "Expected a known output stream." });
-        }
-        return;
-    }
-    if (value.kind === "native") {
-        requireString(value, "tool", path, issues);
-        requireString(value, "outputId", path, issues);
-        return;
-    }
-    issues.push({ path: `${path}.kind`, message: "Expected source kind repo, vault, or native." });
-}
-function validateParserMetadata(value, path, issues) {
-    if (value === undefined) {
-        return;
-    }
-    if (!isRecord(value)) {
-        issues.push({ path, message: "Expected parser metadata object." });
-        return;
-    }
-    requireString(value, "name", path, issues);
-    if (typeof value.confidence !== "number" || !Number.isFinite(value.confidence) || value.confidence < 0 || value.confidence > 1) {
-        issues.push({ path: `${path}.confidence`, message: "Expected confidence between 0 and 1." });
-    }
-    if (value.fidelity !== "exact" && value.fidelity !== "lossy") {
-        issues.push({ path: `${path}.fidelity`, message: "Expected parser fidelity exact or lossy." });
-    }
-    requireBoolean(value, "compressed", path, issues);
-    if (value.counts !== undefined) {
-        if (!isRecord(value.counts)) {
-            issues.push({ path: `${path}.counts`, message: "Expected parser counts object." });
-        }
-        else {
-            for (const [key, count] of Object.entries(value.counts)) {
-                if (typeof count !== "number" || !Number.isFinite(count)) {
-                    issues.push({ path: `${path}.counts.${key}`, message: "Expected finite numeric parser count." });
-                }
-            }
-        }
-    }
-    if (value.references !== undefined) {
-        if (!Array.isArray(value.references)) {
-            issues.push({ path: `${path}.references`, message: "Expected parser references array." });
-        }
-        else {
-            value.references.forEach((reference, index) => validateParserReference(reference, `${path}.references[${index}]`, issues));
-        }
-    }
-}
-function validateParserReference(value, path, issues) {
-    if (!isRecord(value)) {
-        issues.push({ path, message: "Expected parser reference object." });
-        return;
-    }
-    requireString(value, "path", path, issues);
-    requireString(value, "message", path, issues);
-    if (value.line !== undefined) {
-        if (typeof value.line !== "number" || !Number.isInteger(value.line) || value.line <= 0) {
-            issues.push({ path: `${path}.line`, message: "Expected a positive integer line." });
-        }
-    }
-    if (value.column !== undefined) {
-        if (typeof value.column !== "number" || !Number.isInteger(value.column) || value.column <= 0) {
-            issues.push({ path: `${path}.column`, message: "Expected a positive integer column." });
-        }
-    }
-    if (value.code !== undefined && typeof value.code !== "string") {
-        issues.push({ path: `${path}.code`, message: "Expected parser reference code string." });
-    }
-    if (value.severity !== undefined && value.severity !== "error" && value.severity !== "warning" && value.severity !== "info") {
-        issues.push({ path: `${path}.severity`, message: "Expected parser reference severity error, warning, or info." });
-    }
-}
-function validateImportantLines(value, path, issues) {
-    if (value === undefined) {
-        return;
-    }
-    if (!Array.isArray(value)) {
-        issues.push({ path, message: "Expected importantLines array." });
-        return;
-    }
-    value.forEach((line, index) => validateImportantLine(line, `${path}[${index}]`, issues));
-}
-function validateImportantLine(value, path, issues) {
-    if (!isRecord(value)) {
-        issues.push({ path, message: "Expected important line object." });
-        return;
-    }
-    if (!isOneOf(value.stream, OUTPUT_STREAMS) || value.stream === "raw") {
-        issues.push({ path: `${path}.stream`, message: "Expected stdout, stderr, or combined stream." });
-    }
-    if (typeof value.lines !== "string" || !validLineRange(value.lines)) {
-        issues.push({ path: `${path}.lines`, message: "Expected line range in start-end form." });
-    }
-    if (typeof value.excerpt !== "string") {
-        issues.push({ path: `${path}.excerpt`, message: "Expected excerpt string." });
-    }
-}
-function validLineRange(value) {
-    const match = /^(\d+)-(\d+)$/.exec(value);
-    if (!match?.[1] || !match[2]) {
-        return false;
-    }
-    const start = Number(match[1]);
-    const end = Number(match[2]);
-    return Number.isInteger(start) && Number.isInteger(end) && start > 0 && end >= start;
-}
-function validateEvidenceArray(value, path, issues) {
-    if (value === undefined) {
-        return;
-    }
-    if (!Array.isArray(value)) {
-        issues.push({ path, message: "Expected an evidence array." });
-        return;
-    }
-    value.forEach((packet, index) => {
-        const result = validateEvidencePacket(packet);
-        if (!result.ok) {
-            for (const issue of result.issues) {
-                issues.push({ path: `${path}[${index}]${issue.path.slice(1)}`, message: issue.message });
-            }
-        }
-    });
-}
-export function validatePreserveMode(value) {
-    if (!isOneOf(value, PRESERVE_MODES)) {
-        return failure([{ path: "$", message: "Expected preserve mode summary, important, or full." }]);
-    }
-    return success(value);
-}
-export function validateRetrievalAction(value) {
-    if (!isOneOf(value, RETRIEVAL_ACTIONS)) {
-        return failure([{ path: "$", message: "Expected retrieval action query, locate, retrieve, expand, or explain." }]);
-    }
-    return success(value);
-}
-export function validateEvidencePacket(value) {
-    const issues = [];
-    if (!isRecord(value)) {
-        return failure([{ path: "$", message: "Expected an evidence packet object." }]);
-    }
-    requireString(value, "id", "$", issues);
-    validateSourceRef(value.source, "$.source", issues);
-    requireString(value, "excerpt", "$", issues);
-    requireString(value, "why", "$", issues);
-    requireBoolean(value, "expandable", "$", issues);
-    if (!isOneOf(value.window, EVIDENCE_WINDOWS)) {
-        issues.push({ path: "$.window", message: "Expected a known evidence window." });
-    }
-    if (value.path !== undefined && typeof value.path !== "string") {
-        issues.push({ path: "$.path", message: "Expected a string when present." });
-    }
-    if (value.lines !== undefined && typeof value.lines !== "string") {
-        issues.push({ path: "$.lines", message: "Expected a string when present." });
-    }
-    return issues.length === 0 ? success(value) : failure(issues);
-}
-export function validateRoutedResult(value) {
-    const issues = [];
-    if (!isRecord(value)) {
-        return failure([{ path: "$", message: "Expected a routed result object." }]);
-    }
-    if ("status" in value) {
-        issues.push({
-            path: "$.status",
-            message: "Do not use ambiguous top-level status; use toolStatus, execution.status, and routing.status.",
-        });
-    }
-    if (!isOneOf(value.toolStatus, TOOL_STATUSES)) {
-        issues.push({ path: "$.toolStatus", message: "Expected toolStatus ok or error." });
-    }
-    requireString(value, "decisionId", "$", issues);
-    if (!isOneOf(value.preserve, PRESERVE_MODES)) {
-        issues.push({ path: "$.preserve", message: "Expected preserve mode summary, important, or full." });
-    }
-    if (!isRecord(value.routing)) {
-        issues.push({ path: "$.routing", message: "Expected routing object." });
-    }
-    else {
-        if (!isOneOf(value.routing.status, ROUTING_STATUSES)) {
-            issues.push({ path: "$.routing.status", message: "Expected a known routing status." });
-        }
-        if (!isOneOf(value.routing.route, ROUTE_KINDS)) {
-            issues.push({ path: "$.routing.route", message: "Expected a known route kind." });
-        }
-        requireString(value.routing, "reason", "$.routing", issues);
-    }
-    if (value.recovery !== undefined) {
-        if (!isRecord(value.recovery)) {
-            issues.push({ path: "$.recovery", message: "Expected recovery object." });
-        }
-        else {
-            requireString(value.recovery, "how", "$.recovery", issues);
-        }
-    }
-    validateEvidenceArray(value.evidence, "$.evidence", issues);
-    if (value.execution !== undefined) {
-        if (!isRecord(value.execution)) {
-            issues.push({ path: "$.execution", message: "Expected execution object." });
-        }
-        else {
-            if (!isOneOf(value.execution.status, EXECUTION_STATUSES)) {
-                issues.push({ path: "$.execution.status", message: "Expected a known execution status." });
-            }
-            requireNullableInteger(value.execution, "exitCode", "$.execution", issues);
-            if (value.execution.durationMs !== undefined) {
-                requireNonNegativeNumber(value.execution, "durationMs", "$.execution", issues);
-            }
-        }
-    }
-    if (value.outputId !== undefined && typeof value.outputId !== "string") {
-        issues.push({ path: "$.outputId", message: "Expected output id string when present." });
-    }
-    validateImportantLines(value.importantLines, "$.importantLines", issues);
-    validateParserMetadata(value.parser, "$.parser", issues);
-    return issues.length === 0 ? success(value) : failure(issues);
-}
-export function validateRouterConfig(value) {
-    const issues = [];
-    if (!isRecord(value)) {
-        return failure([{ path: "$", message: "Expected a router config object." }]);
-    }
-    if (!isValidPostToolRoutingMode(value.postToolRouting)) {
-        issues.push({ path: "$.postToolRouting", message: "Expected postToolRouting off, safety-net, or strict." });
-    }
-    if (!isRecord(value.thresholds)) {
-        issues.push({ path: "$.thresholds", message: "Expected thresholds object." });
-    }
-    else {
-        issues.push(...validatePositiveIntegerThreshold(value.thresholds.largeOutputBytes, "$.thresholds.largeOutputBytes"));
-        issues.push(...validatePositiveIntegerThreshold(value.thresholds.largeOutputLines, "$.thresholds.largeOutputLines"));
-    }
-    if (!isRecord(value.vault)) {
-        issues.push({ path: "$.vault", message: "Expected vault config object." });
-    }
-    else {
-        requireString(value.vault, "root", "$.vault", issues);
-        if (value.vault.retention !== undefined) {
-            issues.push(...validateVaultRetentionPolicy(value.vault.retention, "$.vault.retention"));
-        }
-    }
-    issues.push(...validateNormalizedRouterHints(value.hints, "$.hints"));
-    return issues.length === 0 ? success(value) : failure(issues);
-}
-export function validateCommandOutputRecord(value) {
-    const issues = [];
-    if (!isRecord(value)) {
-        return failure([{ path: "$", message: "Expected a command output record object." }]);
-    }
-    if ("status" in value) {
-        issues.push({
-            path: "$.status",
-            message: "Do not use ambiguous command record status; use executionStatus.",
-        });
-    }
-    if (value.kind !== "command") {
-        issues.push({ path: "$.kind", message: "Expected kind command." });
-    }
-    requireString(value, "outputId", "$", issues);
-    requireString(value, "objectId", "$", issues);
-    requireString(value, "createdAt", "$", issues);
-    requireString(value, "contentHashSha256", "$", issues);
-    const commandIsValid = typeof value.command === "string" ||
-        (Array.isArray(value.command) && value.command.every((part) => typeof part === "string"));
-    if (!commandIsValid) {
-        issues.push({ path: "$.command", message: "Expected command string or string array." });
-    }
-    if (!isOneOf(value.executionStatus, EXECUTION_STATUSES)) {
-        issues.push({ path: "$.executionStatus", message: "Expected a known execution status." });
-    }
-    requireNullableInteger(value, "exitCode", "$", issues);
-    if (!isRecord(value.paths)) {
-        issues.push({ path: "$.paths", message: "Expected command output paths object." });
-    }
-    else {
-        requireString(value.paths, "meta", "$.paths", issues);
-        requireString(value.paths, "stdout", "$.paths", issues);
-        requireString(value.paths, "stderr", "$.paths", issues);
-        requireString(value.paths, "combined", "$.paths", issues);
-    }
-    if (!isRecord(value.lineCounts)) {
-        issues.push({ path: "$.lineCounts", message: "Expected lineCounts object." });
-    }
-    else {
-        requireInteger(value.lineCounts, "stdout", "$.lineCounts", issues);
-        requireInteger(value.lineCounts, "stderr", "$.lineCounts", issues);
-        requireInteger(value.lineCounts, "combined", "$.lineCounts", issues);
-    }
-    if (!isRecord(value.byteCounts)) {
-        issues.push({ path: "$.byteCounts", message: "Expected byteCounts object." });
-    }
-    else {
-        requireInteger(value.byteCounts, "stdout", "$.byteCounts", issues);
-        requireInteger(value.byteCounts, "stderr", "$.byteCounts", issues);
-        requireInteger(value.byteCounts, "combined", "$.byteCounts", issues);
-    }
-    if (!isRecord(value.hashes)) {
-        issues.push({ path: "$.hashes", message: "Expected hashes object." });
-    }
-    if (!Array.isArray(value.decisionIds) || !value.decisionIds.every((item) => typeof item === "string")) {
-        issues.push({ path: "$.decisionIds", message: "Expected decision id string array." });
-    }
-    return issues.length === 0 ? success(value) : failure(issues);
-}

package/plugins/freeflow/router/dist/types.d.ts

@@ -1,234 +0,0 @@
-export declare const PRESERVE_MODES: readonly ["summary", "important", "full"];
-export type PreserveMode = (typeof PRESERVE_MODES)[number];
-export declare const RETRIEVAL_ACTIONS: readonly ["query", "locate", "retrieve", "expand", "explain"];
-export type RetrievalAction = (typeof RETRIEVAL_ACTIONS)[number];
-export declare const TOOL_STATUSES: readonly ["ok", "error"];
-export type ToolStatus = (typeof TOOL_STATUSES)[number];
-export declare const EXECUTION_STATUSES: readonly ["success", "failed", "timed_out", "cancelled"];
-export type ExecutionStatus = (typeof EXECUTION_STATUSES)[number];
-export declare const ROUTING_STATUSES: readonly ["routed", "passed_through", "partial", "failed"];
-export type RoutingStatus = (typeof ROUTING_STATUSES)[number];
-export declare const ROUTE_KINDS: readonly ["retrieve", "run", "safety-net", "pass-through"];
-export type RouteKind = (typeof ROUTE_KINDS)[number];
-export declare const EVIDENCE_WINDOWS: readonly ["exact", "small", "lines_30", "lines_80", "section", "full"];
-export type EvidenceWindow = (typeof EVIDENCE_WINDOWS)[number];
-export declare const OUTPUT_STREAMS: readonly ["stdout", "stderr", "combined", "raw"];
-export type OutputStream = (typeof OUTPUT_STREAMS)[number];
-export declare const POST_TOOL_ROUTING_MODES: readonly ["off", "safety-net", "strict"];
-export type PostToolRoutingMode = (typeof POST_TOOL_ROUTING_MODES)[number];
-export interface RepoSourceRef {
-    kind: "repo";
-    path: string;
-}
-export interface VaultSourceRef {
-    kind: "vault";
-    outputId: string;
-    stream?: OutputStream;
-}
-export interface NativeToolSourceRef {
-    kind: "native";
-    tool: string;
-    outputId: string;
-}
-export type SourceRef = RepoSourceRef | VaultSourceRef | NativeToolSourceRef;
-export interface EvidencePacket {
-    id: string;
-    source: SourceRef;
-    excerpt: string;
-    why: string;
-    window: EvidenceWindow;
-    expandable: boolean;
-    path?: string;
-    lines?: string;
-}
-export interface RecoveryHint {
-    how: string;
-    outputId?: string;
-    evidenceId?: string;
-}
-export interface RoutingDecision {
-    status: RoutingStatus;
-    route: RouteKind;
-    reason: string;
-}
-export interface CommandExecution {
-    status: ExecutionStatus;
-    exitCode: number | null;
-    durationMs?: number;
-}
-export interface ImportantLine {
-    stream: Exclude<OutputStream, "raw">;
-    lines: string;
-    excerpt: string;
-}
-export interface CommandParserReference {
-    path: string;
-    line?: number;
-    column?: number;
-    code?: string;
-    severity?: "error" | "warning" | "info";
-    message: string;
-}
-export interface CommandParserMetadata {
-    name: string;
-    confidence: number;
-    fidelity: "exact" | "lossy";
-    compressed: boolean;
-    counts?: Record<string, number>;
-    references?: CommandParserReference[];
-}
-export interface RoutedResultBase {
-    toolStatus: ToolStatus;
-    decisionId: string;
-    preserve: PreserveMode;
-    routing: RoutingDecision;
-    recovery?: RecoveryHint;
-    evidence?: EvidencePacket[];
-}
-export interface RetrievalRoutedResult extends RoutedResultBase {
-    source?: SourceRef;
-}
-export interface CommandRoutedResult extends RoutedResultBase {
-    outputId: string;
-    execution: CommandExecution;
-    summary?: string;
-    importantLines?: ImportantLine[];
-    parser?: CommandParserMetadata;
-}
-export type RoutedResult = RetrievalRoutedResult | CommandRoutedResult;
-export interface LineByteCounts {
-    lines: number;
-    bytes: number;
-}
-export interface CommandOutputPaths {
-    meta: string;
-    stdout: string;
-    stderr: string;
-    combined: string;
-}
-export interface OutputFingerprints {
-    exactSha256: string;
-    normalizedSha256: string;
-    commandFingerprintSha256?: string;
-}
-export interface VaultRecordBase {
-    outputId: string;
-    objectId: string;
-    createdAt: string;
-    paths: {
-        meta: string;
-    };
-    decisionIds: string[];
-    contentHashSha256: string;
-    fingerprints?: OutputFingerprints;
-    retention?: VaultRetentionPolicy;
-    expiresAt?: string;
-}
-export interface CommandOutputRecord extends VaultRecordBase {
-    kind: "command";
-    command: string | readonly string[];
-    executionStatus: ExecutionStatus;
-    exitCode: number | null;
-    paths: CommandOutputPaths;
-    lineCounts: {
-        stdout: number;
-        stderr: number;
-        combined: number;
-    };
-    byteCounts: {
-        stdout: number;
-        stderr: number;
-        combined: number;
-    };
-    hashes: {
-        stdoutSha256?: string;
-        stderrSha256?: string;
-        combinedSha256?: string;
-    };
-    fingerprints: OutputFingerprints & {
-        commandFingerprintSha256: string;
-    };
-    cwd?: string;
-    durationMs?: number;
-}
-export interface TextOutputRecord extends VaultRecordBase {
-    kind: "text";
-    sourceKind: "native" | "mcp" | "fetch" | "other";
-    paths: {
-        meta: string;
-        raw: string;
-    };
-    lineCounts: {
-        raw: number;
-    };
-    byteCounts: {
-        raw: number;
-    };
-    hashes: {
-        rawSha256?: string;
-    };
-    fingerprints: OutputFingerprints;
-}
-export interface RepoFileReferenceRecord extends VaultRecordBase {
-    kind: "repo-file";
-    path: string;
-    paths: {
-        meta: string;
-    };
-    hashSha256?: string;
-}
-export type VaultRecord = CommandOutputRecord | TextOutputRecord | RepoFileReferenceRecord;
-export interface SessionIndexEntry {
-    outputId: string;
-    objectId: string;
-    kind: VaultRecord["kind"];
-    createdAt: string;
-    executionStatus?: ExecutionStatus;
-    fingerprints?: OutputFingerprints;
-}
-export interface VaultSessionIndex {
-    version: 1;
-    sessionId: string;
-    createdAt: string;
-    updatedAt: string;
-    outputs: string[];
-    records: Record<string, SessionIndexEntry>;
-    successful: string[];
-    failed: string[];
-    timedOut: string[];
-    cancelled: string[];
-}
-export interface DecisionRecord {
-    decisionId: string;
-    createdAt: string;
-    route: RouteKind;
-    preserve: PreserveMode;
-    reason: string;
-    source?: SourceRef;
-    outputId?: string;
-    evidenceIds?: string[];
-}
-export interface RouterThresholds {
-    largeOutputBytes: number;
-    largeOutputLines: number;
-}
-export type VaultRetentionPolicy = {
-    strategy: "ttl";
-    ttlDays: number;
-} | {
-    strategy: "manual";
-};
-export interface RouterVaultConfig {
-    root: string;
-    retention?: VaultRetentionPolicy;
-}
-export interface RouterHints {
-    generatedPathGlobs?: string[];
-    noisyCommandPatterns?: string[];
-}
-export interface RouterConfig {
-    postToolRouting: PostToolRoutingMode;
-    thresholds: RouterThresholds;
-    vault: RouterVaultConfig;
-    hints?: RouterHints;
-}

package/plugins/freeflow/router/dist/types.js

@@ -1,9 +0,0 @@
-export const PRESERVE_MODES = ["summary", "important", "full"];
-export const RETRIEVAL_ACTIONS = ["query", "locate", "retrieve", "expand", "explain"];
-export const TOOL_STATUSES = ["ok", "error"];
-export const EXECUTION_STATUSES = ["success", "failed", "timed_out", "cancelled"];
-export const ROUTING_STATUSES = ["routed", "passed_through", "partial", "failed"];
-export const ROUTE_KINDS = ["retrieve", "run", "safety-net", "pass-through"];
-export const EVIDENCE_WINDOWS = ["exact", "small", "lines_30", "lines_80", "section", "full"];
-export const OUTPUT_STREAMS = ["stdout", "stderr", "combined", "raw"];
-export const POST_TOOL_ROUTING_MODES = ["off", "safety-net", "strict"];

package/plugins/freeflow/router/dist/vault.d.ts

@@ -1,80 +0,0 @@
-import type { CommandOutputRecord, ExecutionStatus, OutputFingerprints, OutputStream, RepoFileReferenceRecord, RouterVaultConfig, SessionIndexEntry, TextOutputRecord, VaultRecord, VaultRetentionPolicy, VaultSessionIndex } from "./types.js";
-export interface VaultHandle {
-    root: string;
-    retention: VaultRetentionPolicy;
-}
-export interface CreateVaultOptions extends Partial<RouterVaultConfig> {
-}
-export interface StoreCommandOutputOptions {
-    sessionId: string;
-    command: string | readonly string[];
-    stdout: string;
-    stderr: string;
-    executionStatus: ExecutionStatus;
-    exitCode: number | null;
-    combined?: string;
-    cwd?: string;
-    durationMs?: number;
-    decisionIds?: string[];
-    createdAt?: string;
-}
-export interface StoreTextOutputOptions {
-    sessionId: string;
-    raw: string;
-    sourceKind: TextOutputRecord["sourceKind"];
-    decisionIds?: string[];
-    createdAt?: string;
-}
-export interface StoreRepoFileReferenceOptions {
-    sessionId: string;
-    path: string;
-    hashSha256?: string;
-    decisionIds?: string[];
-    createdAt?: string;
-}
-export interface ReadOutputLinesOptions {
-    sessionId: string;
-    outputId: string;
-    stream: OutputStream;
-    startLine: number;
-    endLine: number;
-}
-export interface CommandOutputFingerprintOptions {
-    command: string | readonly string[];
-    stdout: string;
-    stderr: string;
-    executionStatus: ExecutionStatus;
-    exitCode: number | null;
-    combined?: string;
-    cwd?: string;
-}
-export interface TextOutputFingerprintOptions {
-    raw: string;
-}
-export interface FindExactDuplicateCommandOutputOptions {
-    sessionId: string;
-    fingerprints: OutputFingerprints & {
-        commandFingerprintSha256: string;
-    };
-    excludeOutputId?: string;
-}
-export interface FindExactDuplicateTextOutputOptions {
-    sessionId: string;
-    fingerprints: OutputFingerprints;
-    excludeOutputId?: string;
-}
-export declare function createVault(options?: CreateVaultOptions): VaultHandle;
-export declare function resolveVaultRoot(root: string): string;
-export declare function commandOutputFingerprints(options: CommandOutputFingerprintOptions): OutputFingerprints & {
-    commandFingerprintSha256: string;
-};
-export declare function textOutputFingerprints(options: TextOutputFingerprintOptions): OutputFingerprints;
-export declare function findExactDuplicateCommandOutput(vault: VaultHandle, options: FindExactDuplicateCommandOutputOptions): Promise<SessionIndexEntry | undefined>;
-export declare function findExactDuplicateTextOutput(vault: VaultHandle, options: FindExactDuplicateTextOutputOptions): Promise<SessionIndexEntry | undefined>;
-export declare function storeCommandOutput(vault: VaultHandle, options: StoreCommandOutputOptions): Promise<CommandOutputRecord>;
-export declare function storeTextOutput(vault: VaultHandle, options: StoreTextOutputOptions): Promise<TextOutputRecord>;
-export declare function storeRepoFileReference(vault: VaultHandle, options: StoreRepoFileReferenceOptions): Promise<RepoFileReferenceRecord>;
-export declare function readVaultRecord(vault: VaultHandle, sessionId: string, outputId: string): Promise<VaultRecord>;
-export declare function readOutputText(vault: VaultHandle, sessionId: string, outputId: string, stream: OutputStream): Promise<string>;
-export declare function readOutputLines(vault: VaultHandle, options: ReadOutputLinesOptions): Promise<string>;
-export declare function readSessionIndex(vault: VaultHandle, sessionId: string): Promise<VaultSessionIndex>;