import { R as ReplaySource, a as ReplayWarning, b as ImportTurn, B as BulkImportSource, c as BulkImportOptions, d as BulkImportResult, e as ReplayTurn, O as Orchestrator, C as CompoundingPromotionReport } from './orchestrator-ChkesB8U.js';
import { M as MemoryGovernanceRunResult, c as MemoryGovernanceSummary, d as MemoryGovernanceMetrics, e as MemoryGovernanceQualityScore, f as MemoryGovernanceReviewQueueEntry, g as MemoryGovernanceAppliedAction, h as MemoryGovernanceTransitionReport, i as MemoryGovernanceManifest, j as MemoryGovernanceRestoreManifest, R as RestoreMemoryGovernanceRunResult } from './memory-projection-store-D3vBHS4J.js';
import { MemoryStatus, MemoryFile, BehaviorSignalEvent, QmdSearchResult, MemoryActionEvent, MemoryLifecycleEvent } from './types.js';
import { Writable, Readable } from 'node:stream';
import { DashboardStatus } from './dashboard-runtime.js';
import { E as EngramAccessService } from './access-service-_AEUMVyX.js';
import { ResolveSecretRefFn } from './resolve-auth-token.js';
import { EvalBaselineDeltaReport, EvalBaselineSnapshot, EvalCiGateReport, EvalBenchmarkPackSummary, EvalHarnessStatus, EvalStoredBaselineCiGateReport } from './evals.js';
import { GraphHealthReport } from './graph.js';
import { CausalTrajectoryStoreStatus } from './causal-trajectory.js';
import { AbstractionNodeStoreStatus } from './abstraction-nodes.js';
import { CueAnchorStoreStatus } from './cue-anchors.js';
import { HarmonicRetrievalResult } from './harmonic-retrieval.js';
import { VerifiedEpisodeResult } from './verified-recall.js';
import { VerifiedSemanticRuleResult } from './semantic-rule-verifier.js';
import { CommitmentLedgerLifecycleResult, CommitmentLedgerEntry, CommitmentLedgerStatus } from './commitment-ledger.js';
import { WorkProductLedgerSearchResult, WorkProductLedgerEntry, WorkProductLedgerStatus } from './work-product-ledger.js';
import { UtilityTelemetryEvent, UtilityTelemetryStatus } from './utility-telemetry.js';
import { UtilityLearningResult, UtilityLearningStatus } from './utility-learner.js';
import { ResumeBundle, ResumeBundleStatus } from './resume-bundles.js';
import { SemanticRulePromotionReport } from './semantic-rule-promotion.js';
import { ObjectiveStateStoreStatus } from './objective-state.js';
import { TrustZoneDemoSeedResult, TrustZoneName, TrustZonePromotionResult, TrustZoneStoreStatus } from './trust-zones.js';
import { SessionIntegrityReport, SessionRepairPlan, SessionRepairApplyResult } from './session-integrity.js';
import { TierMigrationStatusSnapshot, TierMigrationCycleSummary } from './recall-state.js';
import { RuntimePolicyValues } from './policy-runtime.js';

interface MigrateObservationsResult {
    dryRun: boolean;
    scannedFiles: number;
    parsedRows: number;
    malformedLines: number;
    migratedRows: number;
    outputPath: string;
    backupPath?: string;
    sourceRelativePaths: string[];
}

interface RebuildMemoryProjectionResult {
    dryRun: boolean;
    scannedMemories: number;
    currentRows: number;
    timelineRows: number;
    entityMentionRows: number;
    nativeKnowledgeRows: number;
    reviewQueueRows: number;
    outputPath: string;
    backupPath?: string;
    usedLifecycleLedger: boolean;
    scope: {
        updatedAfter: string | null;
        updatedBefore: string | null;
    };
}
interface VerifyMemoryProjectionResult {
    outputPath: string;
    projectionExists: boolean;
    ok: boolean;
    expectedCurrentRows: number;
    actualCurrentRows: number;
    expectedTimelineRows: number;
    actualTimelineRows: number;
    expectedEntityMentionRows: number;
    actualEntityMentionRows: number;
    expectedNativeKnowledgeRows: number;
    actualNativeKnowledgeRows: number;
    expectedReviewQueueRows: number;
    actualReviewQueueRows: number;
    missingCurrentMemoryIds: string[];
    extraCurrentMemoryIds: string[];
    mismatchedCurrentMemoryIds: string[];
    missingTimelineEventIds: string[];
    extraTimelineEventIds: string[];
    missingEntityMentionKeys: string[];
    extraEntityMentionKeys: string[];
    mismatchedEntityMentionKeys: string[];
    missingNativeKnowledgeChunkIds: string[];
    extraNativeKnowledgeChunkIds: string[];
    mismatchedNativeKnowledgeChunkIds: string[];
    missingReviewQueueEntryIds: string[];
    extraReviewQueueEntryIds: string[];
    mismatchedReviewQueueEntryIds: string[];
    usedLifecycleLedger: boolean;
    scope: {
        updatedAfter: string | null;
        updatedBefore: string | null;
    };
}
interface RepairMemoryProjectionResult {
    dryRun: boolean;
    repaired: boolean;
    verify: VerifyMemoryProjectionResult;
    rebuild?: RebuildMemoryProjectionResult;
}

interface RebuildMemoryLifecycleLedgerResult {
    dryRun: boolean;
    scannedMemories: number;
    rebuiltRows: number;
    outputPath: string;
    backupPath?: string;
}

interface RebuildObservationsResult {
    dryRun: boolean;
    scannedFiles: number;
    parsedTurns: number;
    malformedLines: number;
    rebuiltRows: number;
    outputPath: string;
    backupPath?: string;
}

interface ArchiveObservationsResult {
    dryRun: boolean;
    retentionDays: number;
    scannedFiles: number;
    archivedFiles: number;
    archivedBytes: number;
    archiveRoot: string;
    archivedRelativePaths: string[];
}

interface ReplayRunSummary {
    source: ReplaySource;
    parsedTurns: number;
    validTurns: number;
    invalidTurns: number;
    filteredByDate: number;
    skippedByOffset: number;
    processedTurns: number;
    batchCount: number;
    dryRun: boolean;
    nextOffset: number;
    firstTimestamp?: string;
    lastTimestamp?: string;
    warnings: ReplayWarning[];
}

interface ProcessBatchResult {
    memoriesCreated: number;
    duplicatesSkipped: number;
    /**
     * Number of entities created by the batch. Optional so Phase-1 stubs that
     * only count memories can omit it; when absent it is treated as 0.
     */
    entitiesCreated?: number;
}
type ProcessBatchFn = (turns: ImportTurn[]) => Promise<ProcessBatchResult>;
/**
 * Format a batch of turns into a conversation transcript string.
 */
declare function formatBatchTranscript(turns: ImportTurn[]): string;
/**
 * Run the bulk-import pipeline over a parsed source.
 *
 * Splits turns into batches and delegates each to `processBatch`.
 * In dryRun mode, validates and counts without calling `processBatch`.
 */
declare function runBulkImportPipeline(source: BulkImportSource, options: BulkImportOptions | undefined, processBatch: ProcessBatchFn): Promise<BulkImportResult>;

type WorkTaskStatus = "todo" | "in_progress" | "blocked" | "done" | "cancelled";
type WorkTaskPriority = "low" | "medium" | "high";
type WorkProjectStatus = "active" | "on_hold" | "completed" | "archived";

type RoutePatternType = "regex" | "keyword";

interface TailscaleSyncOptions {
    sourceDir: string;
    destination: string;
    delete?: boolean;
    dryRun?: boolean;
    extraArgs?: string[];
}

type CompatLevel = "ok" | "warn" | "error";
interface CompatCheckResult {
    id: string;
    title: string;
    level: CompatLevel;
    message: string;
    remediation?: string;
    metadata?: Record<string, unknown>;
}
interface CompatSummary {
    ok: number;
    warn: number;
    error: number;
}
interface CompatReport {
    generatedAt: string;
    checks: CompatCheckResult[];
    summary: CompatSummary;
}
interface CompatRunner {
    commandExists(command: string): Promise<boolean>;
}

/**
 * Parse a strict ISO 8601 date string, rejecting malformed inputs, calendar
 * overflows, and out-of-range time components with a descriptive error.
 *
 * Accepted forms:
 *   YYYY-MM-DD
 *   YYYY-MM-DDTHH:mm:ss                (naive / local time)
 *   YYYY-MM-DDTHH:mm:ss.sssZ           (UTC)
 *   YYYY-MM-DDTHH:mm:ss+HH:MM          (with timezone offset)
 *   YYYY-MM-DDTHH:mm:ss.sss-HH:MM      (with timezone offset)
 *
 * `flagName` is included in the error message so users can identify which
 * input failed (e.g. `--since` vs. `--until`).
 */
declare function parseStrictCliDate$1(value: string, flagName: string): Date;

interface CliApi {
    registerCli(handler: (opts: {
        program: CliProgram;
    }) => void, options: {
        commands: string[];
    }): void;
}
type RegisterCliOptions = {
    resolveSecretRef?: ResolveSecretRefFn | null;
    loadResolveSecretRef?: () => Promise<ResolveSecretRefFn | null | undefined> | ResolveSecretRefFn | null | undefined;
};
interface CliProgram {
    command(name: string): CliCommand;
}
interface CliCommand {
    description(desc: string): CliCommand;
    option(flags: string, desc: string, parserOrDefault?: string | ((value: string, prev: unknown) => unknown), defaultValue?: unknown): CliCommand;
    requiredOption(flags: string, desc: string, defaultValue?: string): CliCommand;
    argument(name: string, desc: string): CliCommand;
    action(fn: (...args: unknown[]) => Promise<void> | void): CliCommand;
    command(name: string): CliCommand;
}
interface EngramMcpServerLike {
    runStdio(input: Readable, output: Writable): Promise<void>;
}
interface DedupeCandidate {
    path: string;
    content: string;
    frontmatter: {
        id?: string;
        confidence?: number;
        updated?: string;
        created?: string;
    };
}
interface ExactDedupePlan {
    groups: number;
    duplicates: number;
    keepPaths: string[];
    deletePaths: string[];
}
declare function planExactDuplicateDeletions(memories: DedupeCandidate[]): ExactDedupePlan;
declare function planAggressiveDuplicateDeletions(memories: DedupeCandidate[]): ExactDedupePlan;
interface ReplayCliCommandOptions {
    source: ReplaySource;
    inputPath: string;
    from?: string;
    to?: string;
    dryRun?: boolean;
    startOffset?: number;
    maxTurns?: number;
    batchSize?: number;
    defaultSessionKey?: string;
    strict?: boolean;
    runConsolidation?: boolean;
    extractionIdleTimeoutMs?: number;
}
interface ReplayCliOrchestrator {
    ingestReplayBatch(turns: ReplayTurn[], options?: {
        deadlineMs?: number;
    }): Promise<void>;
    waitForConsolidationIdle(timeoutMs?: number): Promise<boolean>;
    runConsolidationNow(): Promise<{
        memoriesProcessed: number;
        merged: number;
        invalidated: number;
    }>;
}
interface ArchiveObservationsCliCommandOptions {
    memoryDir: string;
    retentionDays?: number;
    write?: boolean;
    now?: Date;
}
interface RebuildObservationsCliCommandOptions {
    memoryDir: string;
    write?: boolean;
    now?: Date;
}
interface RebuildMemoryLifecycleLedgerCliCommandOptions {
    memoryDir: string;
    write?: boolean;
    now?: Date;
}
interface RebuildMemoryProjectionCliCommandOptions {
    memoryDir: string;
    defaultNamespace?: string;
    write?: boolean;
    now?: Date;
    updatedAfter?: string;
    updatedBefore?: string;
}
interface VerifyMemoryProjectionCliCommandOptions {
    memoryDir: string;
    defaultNamespace?: string;
    updatedAfter?: string;
    updatedBefore?: string;
}
interface RepairMemoryProjectionCliCommandOptions {
    memoryDir: string;
    defaultNamespace?: string;
    write?: boolean;
    now?: Date;
    updatedAfter?: string;
    updatedBefore?: string;
}
interface MemoryTimelineCliCommandOptions {
    memoryDir: string;
    memoryId: string;
    limit?: number;
}
interface MemoryGovernanceCliCommandOptions {
    memoryDir: string;
    mode: "shadow" | "apply";
    now?: Date;
    maxMemories?: number;
    batchSize?: number;
    recentDays?: number;
}
interface MemoryGovernanceReportCliCommandOptions {
    memoryDir: string;
    runId?: string;
}
interface MemoryGovernanceRestoreCliCommandOptions {
    memoryDir: string;
    runId: string;
    now?: Date;
}
interface MemoryReviewDispositionCliCommandOptions {
    memoryDir: string;
    memoryId: string;
    status: Extract<MemoryStatus, "active" | "pending_review" | "rejected" | "quarantined">;
    reasonCode?: string;
    now?: Date;
}
interface MigrateObservationsCliCommandOptions {
    memoryDir: string;
    write?: boolean;
    now?: Date;
}
interface WorkTaskPatchInput {
    title?: string;
    description?: string;
    status?: WorkTaskStatus;
    priority?: WorkTaskPriority;
    owner?: string | null;
    assignee?: string | null;
    projectId?: string | null;
    tags?: string[];
    dueAt?: string | null;
}
interface WorkProjectPatchInput {
    name?: string;
    description?: string;
    status?: WorkProjectStatus;
    owner?: string | null;
    tags?: string[];
}
interface WorkTaskCliCommandOptions {
    memoryDir: string;
    action: "create" | "get" | "list" | "update" | "transition" | "delete" | "link";
    id?: string;
    title?: string;
    description?: string;
    status?: WorkTaskStatus;
    priority?: WorkTaskPriority;
    owner?: string;
    assignee?: string;
    projectId?: string;
    tags?: string[];
    dueAt?: string;
    patch?: WorkTaskPatchInput;
}
interface WorkProjectCliCommandOptions {
    memoryDir: string;
    action: "create" | "get" | "list" | "update" | "delete";
    id?: string;
    name?: string;
    description?: string;
    status?: WorkProjectStatus;
    owner?: string;
    tags?: string[];
    patch?: WorkProjectPatchInput;
}
interface RouteCliCommandOptions {
    memoryDir: string;
    stateFile?: string;
    action: "list" | "add" | "remove" | "test";
    pattern?: string;
    patternType?: RoutePatternType;
    priority?: number;
    targetRaw?: string;
    text?: string;
    id?: string;
}
interface TailscaleHelperLike {
    status(): Promise<{
        available: boolean;
        running: boolean;
        backendState?: string;
        version?: string;
        selfHostname?: string;
        selfIp?: string;
    }>;
    syncDirectory(options: TailscaleSyncOptions): Promise<void>;
}
interface ConversationIndexHealthCliOrchestrator {
    getConversationIndexHealth(): Promise<{
        enabled: boolean;
        backend: "qmd" | "faiss";
        status: "ok" | "degraded" | "disabled";
        chunkDocCount: number;
        lastUpdateAt: string | null;
        qmdAvailable?: boolean;
        faiss?: {
            ok: boolean;
            status: "ok" | "degraded" | "error";
            indexPath: string;
            message?: string;
            manifest?: {
                version: number;
                modelId: string;
                normalizedModelId: string;
                dimension: number;
                chunkCount: number;
                updatedAt: string;
                lastSuccessfulRebuildAt: string;
            };
        };
    }>;
    inspectConversationIndex(): Promise<{
        enabled: boolean;
        backend: "qmd" | "faiss";
        status: "ok" | "degraded" | "disabled";
        available: boolean;
        indexPath: string;
        supportsIncrementalUpdate: boolean;
        message?: string;
        chunkDocCount: number;
        lastUpdateAt: string | null;
        metadata: {
            chunkCount: number | null;
            qmdAvailable?: boolean;
            debugStatus?: string;
            hasIndex?: boolean;
            hasMetadata?: boolean;
            hasManifest?: boolean;
            manifest?: {
                version: number;
                modelId: string;
                normalizedModelId: string;
                dimension: number;
                chunkCount: number;
                updatedAt: string;
                lastSuccessfulRebuildAt: string;
            };
        };
    }>;
    rebuildConversationIndex(sessionKey?: string, hours?: number, opts?: {
        embed?: boolean;
    }): Promise<{
        chunks: number;
        skipped: boolean;
        reason?: string;
        embedded?: boolean;
        rebuilt?: boolean;
    }>;
}
interface GraphHealthCliCommandOptions {
    memoryDir: string;
    entityGraphEnabled?: boolean;
    timeGraphEnabled?: boolean;
    causalGraphEnabled?: boolean;
    includeRepairGuidance?: boolean;
}
interface SessionIntegrityCliCommandOptions {
    memoryDir: string;
}
interface SessionRepairCliCommandOptions {
    memoryDir: string;
    apply?: boolean;
    dryRun?: boolean;
    allowSessionFileRepair?: boolean;
    sessionFilesDir?: string;
}
interface TierMigrationCliOrchestrator {
    getTierMigrationStatus(): Promise<TierMigrationStatusSnapshot>;
    runTierMigrationNow(options?: {
        dryRun?: boolean;
        limit?: number;
    }): Promise<TierMigrationCycleSummary>;
}
interface MemoryActionAuditCliCommandOptions {
    namespace?: string;
    limit?: number;
}
interface MemoryActionAuditCliNamespaceSummary {
    namespace: string;
    eventCount: number;
    actions: Record<string, number>;
    outcomes: Record<string, number>;
    policyDecisions: Record<string, number>;
}
interface MemoryActionAuditCliReport {
    generatedAt: string;
    limit: number;
    namespaces: MemoryActionAuditCliNamespaceSummary[];
    totals: {
        eventCount: number;
        actions: Record<string, number>;
        outcomes: Record<string, number>;
        policyDecisions: Record<string, number>;
    };
}
interface MemoryActionAuditCliOrchestrator {
    config: {
        defaultNamespace: string;
        sharedNamespace: string;
        namespacesEnabled: boolean;
        namespacePolicies: Array<{
            name: string;
        }>;
    };
    getStorage(namespace?: string): Promise<{
        readMemoryActionEvents(limit?: number): Promise<MemoryActionEvent[]>;
    }>;
}
interface TailscaleStatusCliCommandOptions {
    helper?: TailscaleHelperLike;
    timeoutMs?: number;
}
interface TailscaleSyncCliCommandOptions extends TailscaleSyncOptions {
    helper?: TailscaleHelperLike;
}
interface WebDavServerLike {
    start(): Promise<{
        running: boolean;
        host: string;
        port: number;
        rootCount: number;
    }>;
    stop(): Promise<void>;
    status(): {
        running: boolean;
        host: string;
        port: number;
        rootCount: number;
    };
}
interface WebDavServeCliCommandOptions {
    enabled?: boolean;
    host?: string;
    port?: number;
    allowlistDirs: string[];
    authUsername?: string;
    authPassword?: string;
    createServer?: (options: {
        enabled?: boolean;
        host?: string;
        port: number;
        allowlistDirs: string[];
        auth?: {
            username: string;
            password: string;
        };
    }) => Promise<WebDavServerLike>;
}
interface CompatCliCommandOptions {
    repoRoot?: string;
    strict?: boolean;
    runner?: CompatRunner;
    now?: Date;
}
interface DashboardServerLike {
    start(): Promise<DashboardStatus>;
    stop(): Promise<void>;
    status(): DashboardStatus;
}
interface AccessHttpServerLike {
    start(): Promise<{
        running: boolean;
        host: string;
        port: number;
        maxBodyBytes: number;
    }>;
    stop(): Promise<void>;
    status(): {
        running: boolean;
        host: string;
        port: number;
        maxBodyBytes: number;
    };
}
interface DashboardStartCliCommandOptions {
    memoryDir: string;
    host?: string;
    port?: number;
    publicDir?: string;
    createServer?: (options: {
        memoryDir: string;
        host?: string;
        port?: number;
        publicDir?: string;
    }) => DashboardServerLike;
}
interface AccessHttpServeCliCommandOptions {
    service: EngramAccessService;
    enabled?: boolean;
    host?: string;
    port?: number;
    authToken?: string;
    principal?: string;
    maxBodyBytes?: number;
    trustPrincipalHeader?: boolean;
    citationsEnabled?: boolean;
    citationsAutoDetect?: boolean;
    createServer?: (options: {
        service: EngramAccessService;
        host?: string;
        port?: number;
        authToken?: string;
        principal?: string;
        maxBodyBytes?: number;
        trustPrincipalHeader?: boolean;
        citationsEnabled?: boolean;
        citationsAutoDetect?: boolean;
    }) => AccessHttpServerLike;
}
interface TrainingExportCliCommandOptions {
    memoryDir: string;
    format: string;
    output: string;
    since?: string;
    until?: string;
    minConfidence?: number;
    categories?: string[];
    includeEntities?: boolean;
    dryRun?: boolean;
    stdout: Writable;
    stderr: Writable;
}
declare function resolveAccessPrincipalOverride(explicitPrincipal: unknown, configuredPrincipal?: string): string | undefined;
declare function runTrainingExportCliCommand(opts: TrainingExportCliCommandOptions): Promise<void>;
declare function runArchiveObservationsCliCommand(options: ArchiveObservationsCliCommandOptions): Promise<ArchiveObservationsResult>;
declare function runRebuildObservationsCliCommand(options: RebuildObservationsCliCommandOptions): Promise<RebuildObservationsResult>;
declare function runRebuildMemoryLifecycleLedgerCliCommand(options: RebuildMemoryLifecycleLedgerCliCommandOptions): Promise<RebuildMemoryLifecycleLedgerResult>;
declare function runRebuildMemoryProjectionCliCommand(options: RebuildMemoryProjectionCliCommandOptions): Promise<RebuildMemoryProjectionResult>;
declare function runVerifyMemoryProjectionCliCommand(options: VerifyMemoryProjectionCliCommandOptions): Promise<VerifyMemoryProjectionResult>;
declare function runRepairMemoryProjectionCliCommand(options: RepairMemoryProjectionCliCommandOptions): Promise<RepairMemoryProjectionResult>;
declare function runMemoryTimelineCliCommand(options: MemoryTimelineCliCommandOptions): Promise<MemoryLifecycleEvent[]>;
declare function runMemoryGovernanceCliCommand(options: MemoryGovernanceCliCommandOptions): Promise<MemoryGovernanceRunResult>;
declare function runMemoryGovernanceReportCliCommand(options: MemoryGovernanceReportCliCommandOptions): Promise<{
    summary: MemoryGovernanceSummary;
    metrics: MemoryGovernanceMetrics;
    qualityScore: MemoryGovernanceQualityScore;
    keptMemoryIds: string[];
    reviewQueue: MemoryGovernanceReviewQueueEntry[];
    appliedActions: MemoryGovernanceAppliedAction[];
    transitionReport: MemoryGovernanceTransitionReport;
    report: string;
    manifest: MemoryGovernanceManifest;
    restore?: MemoryGovernanceRestoreManifest;
}>;
declare function runMemoryGovernanceRestoreCliCommand(options: MemoryGovernanceRestoreCliCommandOptions): Promise<RestoreMemoryGovernanceRunResult>;
declare function runMemoryReviewDispositionCliCommand(options: MemoryReviewDispositionCliCommandOptions): Promise<{
    memoryId: string;
    status: "active" | "pending_review" | "rejected" | "quarantined";
    reasonCode: string | undefined;
}>;
declare function runMigrateObservationsCliCommand(options: MigrateObservationsCliCommandOptions): Promise<MigrateObservationsResult>;
declare function runConversationIndexHealthCliCommand(orchestrator: ConversationIndexHealthCliOrchestrator): Promise<{
    enabled: boolean;
    backend: "qmd" | "faiss";
    status: "ok" | "degraded" | "disabled";
    chunkDocCount: number;
    lastUpdateAt: string | null;
    qmdAvailable?: boolean;
    faiss?: {
        ok: boolean;
        status: "ok" | "degraded" | "error";
        indexPath: string;
        message?: string;
        manifest?: {
            version: number;
            modelId: string;
            normalizedModelId: string;
            dimension: number;
            chunkCount: number;
            updatedAt: string;
            lastSuccessfulRebuildAt: string;
        };
    };
}>;
declare function runConversationIndexInspectCliCommand(orchestrator: ConversationIndexHealthCliOrchestrator): Promise<{
    enabled: boolean;
    backend: "qmd" | "faiss";
    status: "ok" | "degraded" | "disabled";
    available: boolean;
    indexPath: string;
    supportsIncrementalUpdate: boolean;
    message?: string;
    chunkDocCount: number;
    lastUpdateAt: string | null;
    metadata: {
        chunkCount: number | null;
        qmdAvailable?: boolean;
        debugStatus?: string;
        hasIndex?: boolean;
        hasMetadata?: boolean;
        hasManifest?: boolean;
        manifest?: {
            version: number;
            modelId: string;
            normalizedModelId: string;
            dimension: number;
            chunkCount: number;
            updatedAt: string;
            lastSuccessfulRebuildAt: string;
        };
    };
}>;
declare function runConversationIndexRebuildCliCommand(orchestrator: ConversationIndexHealthCliOrchestrator, options: {
    sessionKey?: string;
    hours?: number;
    embed?: boolean;
}): Promise<{
    chunks: number;
    skipped: boolean;
    reason?: string;
    embedded?: boolean;
    rebuilt?: boolean;
}>;
declare function runGraphHealthCliCommand(options: GraphHealthCliCommandOptions): Promise<GraphHealthReport>;
declare function runBenchmarkStatusCliCommand(options: {
    memoryDir: string;
    evalStoreDir?: string;
    evalHarnessEnabled: boolean;
    evalShadowModeEnabled: boolean;
    benchmarkBaselineSnapshotsEnabled: boolean;
    memoryRedTeamBenchEnabled: boolean;
}): Promise<EvalHarnessStatus>;
declare function runBenchmarkBaselineSnapshotCliCommand(options: {
    memoryDir: string;
    evalStoreDir?: string;
    benchmarkBaselineSnapshotsEnabled: boolean;
    snapshotId: string;
    createdAt?: string;
    notes?: string;
    gitRef?: string;
}): Promise<{
    targetPath: string;
    snapshot: EvalBaselineSnapshot;
}>;
declare function runBenchmarkValidateCliCommand(options: {
    path: string;
    memoryRedTeamBenchEnabled: boolean;
}): Promise<EvalBenchmarkPackSummary>;
declare function runBenchmarkImportCliCommand(options: {
    path: string;
    memoryDir: string;
    evalStoreDir?: string;
    force?: boolean;
    memoryRedTeamBenchEnabled: boolean;
}): Promise<EvalBenchmarkPackSummary & {
    targetDir: string;
    overwritten: boolean;
}>;
declare function runBenchmarkCiGateCliCommand(options: {
    baseEvalStoreDir: string;
    candidateEvalStoreDir: string;
}): Promise<EvalCiGateReport>;
declare function runBenchmarkStoredBaselineCiGateCliCommand(options: {
    baseEvalStoreDir: string;
    candidateEvalStoreDir: string;
    snapshotId: string;
}): Promise<EvalStoredBaselineCiGateReport>;
declare function runBenchmarkBaselineReportCliCommand(options: {
    memoryDir: string;
    evalStoreDir?: string;
    benchmarkDeltaReporterEnabled: boolean;
    snapshotId: string;
}): Promise<EvalBaselineDeltaReport>;
declare function runObjectiveStateStatusCliCommand(options: {
    memoryDir: string;
    objectiveStateStoreDir?: string;
    objectiveStateMemoryEnabled: boolean;
    objectiveStateSnapshotWritesEnabled: boolean;
}): Promise<ObjectiveStateStoreStatus>;
declare function runCausalTrajectoryStatusCliCommand(options: {
    memoryDir: string;
    causalTrajectoryStoreDir?: string;
    causalTrajectoryMemoryEnabled: boolean;
}): Promise<CausalTrajectoryStoreStatus>;
declare function runTrustZoneStatusCliCommand(options: {
    memoryDir: string;
    trustZoneStoreDir?: string;
    trustZonesEnabled: boolean;
    quarantinePromotionEnabled: boolean;
    memoryPoisoningDefenseEnabled: boolean;
}): Promise<TrustZoneStoreStatus>;
declare function runAbstractionNodeStatusCliCommand(options: {
    memoryDir: string;
    abstractionNodeStoreDir?: string;
    harmonicRetrievalEnabled: boolean;
    abstractionAnchorsEnabled: boolean;
}): Promise<AbstractionNodeStoreStatus>;
declare function runCueAnchorStatusCliCommand(options: {
    memoryDir: string;
    abstractionNodeStoreDir?: string;
    harmonicRetrievalEnabled: boolean;
    abstractionAnchorsEnabled: boolean;
}): Promise<CueAnchorStoreStatus>;
declare function runHarmonicSearchCliCommand(options: {
    memoryDir: string;
    abstractionNodeStoreDir?: string;
    harmonicRetrievalEnabled: boolean;
    abstractionAnchorsEnabled: boolean;
    query: string;
    maxResults?: number;
    sessionKey?: string;
}): Promise<HarmonicRetrievalResult[]>;
declare function runVerifiedRecallSearchCliCommand(options: {
    memoryDir: string;
    verifiedRecallEnabled: boolean;
    query: string;
    maxResults?: number;
    boxRecallDays?: number;
}): Promise<VerifiedEpisodeResult[]>;
declare function isNormalRetrievalVisibleMemory(memory: MemoryFile): boolean;
declare function filterNormalMemorySearchResults(results: QmdSearchResult[], storage: {
    readMemoryByPath(path: string): Promise<MemoryFile | null>;
}): Promise<QmdSearchResult[]>;
declare function runSemanticRulePromoteCliCommand(options: {
    memoryDir: string;
    semanticRulePromotionEnabled: boolean;
    sourceMemoryId: string;
    dryRun?: boolean;
}): Promise<SemanticRulePromotionReport>;
declare function runCompoundingPromoteCliCommand(options: {
    memoryDir: string;
    compoundingEnabled: boolean;
    compoundingSemanticEnabled: boolean;
    weekId: string;
    candidateId: string;
    dryRun?: boolean;
}): Promise<CompoundingPromotionReport>;
declare function runSemanticRuleVerifyCliCommand(options: {
    memoryDir: string;
    semanticRuleVerificationEnabled: boolean;
    query: string;
    maxResults?: number;
}): Promise<VerifiedSemanticRuleResult[]>;
declare function runWorkProductStatusCliCommand(options: {
    memoryDir: string;
    workProductLedgerDir?: string;
    creationMemoryEnabled: boolean;
}): Promise<WorkProductLedgerStatus>;
declare function runUtilityTelemetryStatusCliCommand(options: {
    memoryDir: string;
    memoryUtilityLearningEnabled: boolean;
    promotionByOutcomeEnabled: boolean;
}): Promise<UtilityTelemetryStatus>;
declare function runUtilityTelemetryRecordCliCommand(options: {
    memoryDir: string;
    memoryUtilityLearningEnabled: boolean;
    event: UtilityTelemetryEvent;
}): Promise<string | null>;
declare function runUtilityLearningStatusCliCommand(options: {
    memoryDir: string;
    memoryUtilityLearningEnabled: boolean;
    promotionByOutcomeEnabled: boolean;
}): Promise<UtilityLearningStatus>;
declare function runUtilityLearningCliCommand(options: {
    memoryDir: string;
    memoryUtilityLearningEnabled: boolean;
    learningWindowDays?: number;
    minEventCount?: number;
    maxWeightMagnitude?: number;
}): Promise<UtilityLearningResult>;
declare function runWorkProductRecordCliCommand(options: {
    memoryDir: string;
    workProductLedgerDir?: string;
    creationMemoryEnabled: boolean;
    entry: WorkProductLedgerEntry;
}): Promise<string | null>;
declare function runWorkProductRecallSearchCliCommand(options: {
    memoryDir: string;
    workProductLedgerDir?: string;
    creationMemoryEnabled: boolean;
    workProductRecallEnabled: boolean;
    query: string;
    maxResults?: number;
    sessionKey?: string;
}): Promise<WorkProductLedgerSearchResult[]>;
declare function runResumeBundleStatusCliCommand(options: {
    memoryDir: string;
    resumeBundleDir?: string;
    creationMemoryEnabled: boolean;
    resumeBundlesEnabled: boolean;
}): Promise<ResumeBundleStatus>;
declare function runResumeBundleRecordCliCommand(options: {
    memoryDir: string;
    resumeBundleDir?: string;
    creationMemoryEnabled: boolean;
    resumeBundlesEnabled: boolean;
    bundle: ResumeBundle;
}): Promise<string | null>;
declare function runResumeBundleBuildCliCommand(options: {
    memoryDir: string;
    resumeBundleDir?: string;
    objectiveStateStoreDir?: string;
    workProductLedgerDir?: string;
    commitmentLedgerDir?: string;
    creationMemoryEnabled: boolean;
    resumeBundlesEnabled: boolean;
    transcriptEnabled: boolean;
    objectiveStateMemoryEnabled: boolean;
    commitmentLedgerEnabled: boolean;
    bundleId: string;
    recordedAt: string;
    sessionKey: string;
    scope: string;
}): Promise<{
    bundle: ResumeBundle;
    filePath: string;
} | null>;
declare function runCommitmentStatusCliCommand(options: {
    memoryDir: string;
    commitmentLedgerDir?: string;
    creationMemoryEnabled: boolean;
    commitmentLedgerEnabled: boolean;
    commitmentLifecycleEnabled?: boolean;
    commitmentStaleDays?: number;
    commitmentDecayDays?: number;
    now?: string;
}): Promise<CommitmentLedgerStatus>;
declare function runCommitmentRecordCliCommand(options: {
    memoryDir: string;
    commitmentLedgerDir?: string;
    creationMemoryEnabled: boolean;
    commitmentLedgerEnabled: boolean;
    entry: CommitmentLedgerEntry;
}): Promise<string | null>;
declare function runCommitmentSetStateCliCommand(options: {
    memoryDir: string;
    commitmentLedgerDir?: string;
    creationMemoryEnabled: boolean;
    commitmentLedgerEnabled: boolean;
    commitmentLifecycleEnabled: boolean;
    entryId: string;
    nextState: CommitmentLedgerEntry["state"];
    changedAt: string;
}): Promise<CommitmentLedgerEntry | null>;
declare function runCommitmentLifecycleCliCommand(options: {
    memoryDir: string;
    commitmentLedgerDir?: string;
    creationMemoryEnabled: boolean;
    commitmentLedgerEnabled: boolean;
    commitmentLifecycleEnabled: boolean;
    commitmentDecayDays: number;
    now?: string;
}): Promise<CommitmentLedgerLifecycleResult | null>;
declare function runTrustZonePromoteCliCommand(options: {
    memoryDir: string;
    trustZoneStoreDir?: string;
    trustZonesEnabled: boolean;
    quarantinePromotionEnabled: boolean;
    memoryPoisoningDefenseEnabled: boolean;
    sourceRecordId: string;
    targetZone: TrustZoneName;
    promotionReason: string;
    recordedAt?: string;
    summary?: string;
    dryRun?: boolean;
}): Promise<TrustZonePromotionResult & {
    dryRun: boolean;
}>;
declare function runTrustZoneDemoSeedCliCommand(options: {
    memoryDir: string;
    trustZoneStoreDir?: string;
    trustZonesEnabled: boolean;
    scenario?: string;
    recordedAt?: string;
    dryRun?: boolean;
}): Promise<TrustZoneDemoSeedResult>;
declare function runSessionCheckCliCommand(options: SessionIntegrityCliCommandOptions): Promise<SessionIntegrityReport>;
declare function runSessionRepairCliCommand(options: SessionRepairCliCommandOptions): Promise<{
    report: SessionIntegrityReport;
    plan: SessionRepairPlan;
    applyResult: SessionRepairApplyResult;
}>;
declare function runTierStatusCliCommand(orchestrator: TierMigrationCliOrchestrator): Promise<TierMigrationStatusSnapshot>;
declare function runTierMigrateCliCommand(orchestrator: TierMigrationCliOrchestrator, options?: {
    dryRun?: boolean;
    limit?: number;
}): Promise<TierMigrationCycleSummary>;
type MigrateMemoryStorage = {
    readAllMemories(): Promise<MemoryFile[]>;
    readArchivedMemories(): Promise<MemoryFile[]>;
    writeMemoryFrontmatter(memory: MemoryFile, patch: Partial<MemoryFile["frontmatter"]>): Promise<boolean>;
    getChunksForParent(parentId: string): Promise<MemoryFile[]>;
    updateMemory(id: string, newContent: string): Promise<boolean>;
    updateMemoryFrontmatter(id: string, patch: Partial<MemoryFile["frontmatter"]>): Promise<boolean>;
    writeChunk(parentId: string, chunkIndex: number, chunkTotal: number, category: MemoryFile["frontmatter"]["category"], content: string, options?: {
        confidence?: number;
        tags?: string[];
        entityRef?: string;
        source?: string;
        importance?: MemoryFile["frontmatter"]["importance"];
        intentGoal?: string;
        intentActionType?: string;
        intentEntityTypes?: string[];
        memoryKind?: MemoryFile["frontmatter"]["memoryKind"];
    }): Promise<string>;
    invalidateMemory(id: string): Promise<boolean>;
    appendReextractJobs(events: Array<{
        memoryId: string;
        model: string;
        requestedAt: string;
        source: "cli-migrate";
    }>): Promise<number>;
};
interface MigrateCliOrchestrator {
    config: {
        defaultNamespace: string;
    };
    getStorage(namespace?: string): Promise<MigrateMemoryStorage>;
}
interface MigrateCliReport {
    action: "normalize-frontmatter" | "rescore-importance" | "rechunk" | "reextract";
    dryRun: boolean;
    scanned: number;
    changed: number;
    queued: number;
    limit: number;
    model?: string;
}
declare function runMigrateNormalizeFrontmatterCliCommand(orchestrator: MigrateCliOrchestrator, options?: {
    write?: boolean;
    limit?: number;
}): Promise<MigrateCliReport>;
declare function runMigrateRescoreImportanceCliCommand(orchestrator: MigrateCliOrchestrator, options?: {
    write?: boolean;
    limit?: number;
}): Promise<MigrateCliReport>;
declare function runMigrateRechunkCliCommand(orchestrator: MigrateCliOrchestrator, options?: {
    write?: boolean;
    limit?: number;
}): Promise<MigrateCliReport>;
declare function runMigrateReextractCliCommand(orchestrator: MigrateCliOrchestrator, options: {
    model: string;
    write?: boolean;
    limit?: number;
}): Promise<MigrateCliReport>;
interface RuntimePolicySnapshotPayload {
    version: number;
    updatedAt: string;
    values: RuntimePolicyValues;
    sourceAdjustmentCount: number;
}
interface PolicySignalContribution {
    signalType: string;
    direction: string;
    count: number;
    lastSeenAt: string;
}
interface PolicyStatusCliReport {
    generatedAt: string;
    autoTuneEnabled: boolean;
    current: (RuntimePolicySnapshotPayload & {
        policyVersion: string;
    }) | null;
    previous: (RuntimePolicySnapshotPayload & {
        policyVersion: string;
    }) | null;
    topContributingSignals: PolicySignalContribution[];
}
interface PolicyDiffEntry {
    parameter: string;
    previousValue: number | null;
    nextValue: number | null;
    delta: number;
    evidenceCount: number;
}
interface PolicyDiffCliReport {
    generatedAt: string;
    since: string;
    sinceIso: string;
    currentPolicyVersion: string | null;
    previousPolicyVersion: string | null;
    deltas: PolicyDiffEntry[];
    topContributingSignals: PolicySignalContribution[];
}
interface PolicyRollbackCliReport {
    generatedAt: string;
    rolledBack: boolean;
    current: (RuntimePolicySnapshotPayload & {
        policyVersion: string;
    }) | null;
}
interface PolicyTuningCliOrchestrator {
    config: {
        memoryDir: string;
        defaultNamespace: string;
        sharedNamespace: string;
        namespacesEnabled: boolean;
        behaviorLoopAutoTuneEnabled: boolean;
        behaviorLoopLearningWindowDays: number;
        lifecycleArchiveDecayThreshold: number;
        recencyWeight: number;
        lifecyclePromoteHeatThreshold: number;
        lifecycleStaleDecayThreshold: number;
        cronRecallInstructionHeavyTokenCap: number;
        namespacePolicies: Array<{
            name: string;
        }>;
    };
    getStorage(namespace?: string): Promise<{
        readBehaviorSignals(limit?: number): Promise<BehaviorSignalEvent[]>;
    }>;
    rollbackBehaviorRuntimePolicy(): Promise<boolean>;
}
/**
 * Parse a date string strictly. Thin re-export of the canonical
 * implementation in `training-export/date-parse.ts` so that the
 * `@remnic/cli` front-end and the core CLI use identical semantics
 * (CLAUDE.md #22: shared helpers must not be re-implemented per caller).
 *
 * Existing imports of `parseStrictCliDate` from `./cli.js` continue to
 * work — this re-export preserves backward compatibility for the
 * `cli-date-validation.test.ts` suite.
 */
declare const parseStrictCliDate: typeof parseStrictCliDate$1;
/**
 * Parse an ISO 8601 duration string (e.g. "P1Y", "P90D", "P6M") or a plain
 * integer number of days (e.g. "365", "90") into milliseconds.
 *
 * Returns null if the value cannot be parsed.
 */
declare function parseDurationToMs(raw: string): number | null;
declare function hasDestructivePurgeFailures(errors: Array<{
    id: string;
}>): boolean;
declare function runPolicyStatusCliCommand(orchestrator: PolicyTuningCliOrchestrator): Promise<PolicyStatusCliReport>;
declare function runPolicyDiffCliCommand(orchestrator: PolicyTuningCliOrchestrator, options?: {
    since?: string;
}): Promise<PolicyDiffCliReport>;
declare function runPolicyRollbackCliCommand(orchestrator: PolicyTuningCliOrchestrator): Promise<PolicyRollbackCliReport>;
declare function runMemoryActionAuditCliCommand(orchestrator: MemoryActionAuditCliOrchestrator, options?: MemoryActionAuditCliCommandOptions): Promise<MemoryActionAuditCliReport>;
declare function runTailscaleStatusCliCommand(options?: TailscaleStatusCliCommandOptions): Promise<{
    available: boolean;
    running: boolean;
    backendState?: string;
    version?: string;
    selfHostname?: string;
    selfIp?: string;
}>;
declare function runTailscaleSyncCliCommand(options: TailscaleSyncCliCommandOptions): Promise<{
    ok: true;
}>;
declare function runWebDavServeCliCommand(options: WebDavServeCliCommandOptions): Promise<{
    running: boolean;
    host: string;
    port: number;
    rootCount: number;
}>;
declare function runWebDavStopCliCommand(): Promise<{
    stopped: boolean;
}>;
declare function runDashboardStartCliCommand(options: DashboardStartCliCommandOptions): Promise<DashboardStatus>;
declare function runDashboardStopCliCommand(): Promise<{
    stopped: boolean;
}>;
declare function runDashboardStatusCliCommand(): Promise<{
    running: false;
} | DashboardStatus>;
declare function runAccessHttpServeCliCommand(options: AccessHttpServeCliCommandOptions): Promise<{
    running: boolean;
    host: string;
    port: number;
    maxBodyBytes: number;
}>;
declare function runAccessHttpStopCliCommand(): Promise<{
    stopped: boolean;
}>;
declare function runAccessHttpStatusCliCommand(): Promise<{
    running: false;
} | {
    running: boolean;
    host: string;
    port: number;
    maxBodyBytes: number;
}>;
declare function runAccessMcpServeCliCommand(service: EngramAccessService, options?: {
    principal?: string;
    createServer?: (service: EngramAccessService, options: {
        principal?: string;
    }) => EngramMcpServerLike;
    stdin?: Readable;
    stdout?: Writable;
}): Promise<{
    ok: true;
}>;
declare function runCompatCliCommand(options?: CompatCliCommandOptions): Promise<{
    report: CompatReport;
    exitCode: number;
}>;
declare function runRouteCliCommand(options: RouteCliCommandOptions): Promise<unknown>;
declare function runWorkTaskCliCommand(options: WorkTaskCliCommandOptions): Promise<unknown>;
declare function runWorkProjectCliCommand(options: WorkProjectCliCommandOptions): Promise<unknown>;
declare function runReplayCliCommand(orchestrator: ReplayCliOrchestrator, options: ReplayCliCommandOptions): Promise<ReplayRunSummary>;
interface BulkImportCliCommandOptions {
    memoryDir: string;
    source: string;
    file: string;
    batchSize?: number;
    dryRun?: boolean;
    verbose?: boolean;
    strict?: boolean;
    /**
     * Optional adapter-specific platform hint forwarded to `adapter.parse`.
     * Some bulk-import adapters (e.g. weclone) accept a platform discriminator
     * so a single adapter can parse Telegram JSON, WeChat JSON, etc. without
     * shipping a separate source for each. When undefined, adapters pick a
     * default based on file shape.
     */
    platform?: string;
    /**
     * Callback that actually performs extraction + persistence for a batch of
     * parsed turns. Supplied by the host CLI (which has the orchestrator in
     * scope). When omitted, non-dryRun invocations fail fast with a clear
     * error — this protects library callers that have not wired persistence
     * yet and keeps the contract explicit rather than silently dropping turns.
     */
    ingestBatch?: ProcessBatchFn;
    stdout: Writable;
    stderr: Writable;
}
declare function runBulkImportCliCommand(opts: BulkImportCliCommandOptions): Promise<BulkImportResult>;
declare function resolveMemoryDirForNamespace(orchestrator: Orchestrator, namespace?: string, options?: {
    rejectUnsupportedOverride?: boolean;
}): Promise<string>;
declare function registerCli(api: CliApi, orchestrator: Orchestrator, registerOptions?: RegisterCliOptions): void;

export { planAggressiveDuplicateDeletions as $, type AccessHttpServeCliCommandOptions as A, type BulkImportCliCommandOptions as B, type CompatCliCommandOptions as C, type DashboardStartCliCommandOptions as D, type ExactDedupePlan as E, type ReplayCliCommandOptions as F, type GraphHealthCliCommandOptions as G, type ReplayCliOrchestrator as H, type RouteCliCommandOptions as I, type SessionRepairCliCommandOptions as J, type TailscaleSyncCliCommandOptions as K, type TierMigrationCliOrchestrator as L, type MemoryActionAuditCliCommandOptions as M, type TrainingExportCliCommandOptions as N, type WorkProjectCliCommandOptions as O, type ProcessBatchFn as P, type WorkTaskCliCommandOptions as Q, type RebuildMemoryLifecycleLedgerCliCommandOptions as R, type SessionIntegrityCliCommandOptions as S, type TailscaleStatusCliCommandOptions as T, filterNormalMemorySearchResults as U, type VerifyMemoryProjectionCliCommandOptions as V, type WebDavServeCliCommandOptions as W, hasDestructivePurgeFailures as X, isNormalRetrievalVisibleMemory as Y, parseDurationToMs as Z, parseStrictCliDate as _, type ProcessBatchResult as a, runTierMigrateCliCommand as a$, planExactDuplicateDeletions as a0, registerCli as a1, resolveAccessPrincipalOverride as a2, resolveMemoryDirForNamespace as a3, runAbstractionNodeStatusCliCommand as a4, runAccessHttpServeCliCommand as a5, runAccessHttpStatusCliCommand as a6, runAccessHttpStopCliCommand as a7, runAccessMcpServeCliCommand as a8, runArchiveObservationsCliCommand as a9, runMemoryGovernanceRestoreCliCommand as aA, runMemoryReviewDispositionCliCommand as aB, runMemoryTimelineCliCommand as aC, runMigrateNormalizeFrontmatterCliCommand as aD, runMigrateObservationsCliCommand as aE, runMigrateRechunkCliCommand as aF, runMigrateReextractCliCommand as aG, runMigrateRescoreImportanceCliCommand as aH, runObjectiveStateStatusCliCommand as aI, runPolicyDiffCliCommand as aJ, runPolicyRollbackCliCommand as aK, runPolicyStatusCliCommand as aL, runRebuildMemoryLifecycleLedgerCliCommand as aM, runRebuildMemoryProjectionCliCommand as aN, runRebuildObservationsCliCommand as aO, runRepairMemoryProjectionCliCommand as aP, runReplayCliCommand as aQ, runResumeBundleBuildCliCommand as aR, runResumeBundleRecordCliCommand as aS, runResumeBundleStatusCliCommand as aT, runRouteCliCommand as aU, runSemanticRulePromoteCliCommand as aV, runSemanticRuleVerifyCliCommand as aW, runSessionCheckCliCommand as aX, runSessionRepairCliCommand as aY, runTailscaleStatusCliCommand as aZ, runTailscaleSyncCliCommand as a_, runBenchmarkBaselineReportCliCommand as aa, runBenchmarkBaselineSnapshotCliCommand as ab, runBenchmarkCiGateCliCommand as ac, runBenchmarkImportCliCommand as ad, runBenchmarkStatusCliCommand as ae, runBenchmarkStoredBaselineCiGateCliCommand as af, runBenchmarkValidateCliCommand as ag, runCausalTrajectoryStatusCliCommand as ah, runCommitmentLifecycleCliCommand as ai, runCommitmentRecordCliCommand as aj, runCommitmentSetStateCliCommand as ak, runCommitmentStatusCliCommand as al, runCompatCliCommand as am, runCompoundingPromoteCliCommand as an, runConversationIndexHealthCliCommand as ao, runConversationIndexInspectCliCommand as ap, runConversationIndexRebuildCliCommand as aq, runCueAnchorStatusCliCommand as ar, runDashboardStartCliCommand as as, runDashboardStatusCliCommand as at, runDashboardStopCliCommand as au, runGraphHealthCliCommand as av, runHarmonicSearchCliCommand as aw, runMemoryActionAuditCliCommand as ax, runMemoryGovernanceCliCommand as ay, runMemoryGovernanceReportCliCommand as az, runBulkImportPipeline as b, runTierStatusCliCommand as b0, runTrainingExportCliCommand as b1, runTrustZoneDemoSeedCliCommand as b2, runTrustZonePromoteCliCommand as b3, runTrustZoneStatusCliCommand as b4, runUtilityLearningCliCommand as b5, runUtilityLearningStatusCliCommand as b6, runUtilityTelemetryRecordCliCommand as b7, runUtilityTelemetryStatusCliCommand as b8, runVerifiedRecallSearchCliCommand as b9, runVerifyMemoryProjectionCliCommand as ba, runWebDavServeCliCommand as bb, runWebDavStopCliCommand as bc, runWorkProductRecallSearchCliCommand as bd, runWorkProductRecordCliCommand as be, runWorkProductStatusCliCommand as bf, runWorkProjectCliCommand as bg, runWorkTaskCliCommand as bh, type ArchiveObservationsCliCommandOptions as c, type ConversationIndexHealthCliOrchestrator as d, type DedupeCandidate as e, formatBatchTranscript as f, type MemoryActionAuditCliNamespaceSummary as g, type MemoryActionAuditCliReport as h, type MemoryGovernanceCliCommandOptions as i, type MemoryGovernanceReportCliCommandOptions as j, type MemoryGovernanceRestoreCliCommandOptions as k, type MemoryReviewDispositionCliCommandOptions as l, type MemoryTimelineCliCommandOptions as m, type MigrateCliOrchestrator as n, type MigrateCliReport as o, parseStrictCliDate$1 as p, type MigrateObservationsCliCommandOptions as q, runBulkImportCliCommand as r, type PolicyDiffCliReport as s, type PolicyDiffEntry as t, type PolicyRollbackCliReport as u, type PolicyStatusCliReport as v, type PolicyTuningCliOrchestrator as w, type RebuildMemoryProjectionCliCommandOptions as x, type RebuildObservationsCliCommandOptions as y, type RepairMemoryProjectionCliCommandOptions as z };
