@remnic/core 1.0.1 → 1.0.3

package/dist/cli-DwIBnp2g.d.ts

@@ -0,0 +1,1240 @@
+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-B9kwlCep.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-DeSXPh1j.js';
+import { MemoryStatus, MemoryFile, BehaviorSignalEvent, MemoryActionEvent, MemoryLifecycleEvent } from './types.js';
+import { Writable, Readable } from 'node:stream';
+import { DashboardStatus } from './dashboard-runtime.js';
+import { EngramAccessService } from './access-service.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;
+}
+interface CliProgram {
+    command(name: string): CliCommand;
+}
+interface CliCommand {
+    description(desc: string): CliCommand;
+    option(flags: string, desc: string, defaultValue?: string): 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 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;
+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): void;
+
+export { resolveMemoryDirForNamespace 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, parseStrictCliDate as U, type VerifyMemoryProjectionCliCommandOptions as V, type WebDavServeCliCommandOptions as W, planAggressiveDuplicateDeletions as X, planExactDuplicateDeletions as Y, registerCli as Z, resolveAccessPrincipalOverride as _, type ProcessBatchResult as a, runTrustZonePromoteCliCommand as a$, runAbstractionNodeStatusCliCommand as a0, runAccessHttpServeCliCommand as a1, runAccessHttpStatusCliCommand as a2, runAccessHttpStopCliCommand as a3, runAccessMcpServeCliCommand as a4, runArchiveObservationsCliCommand as a5, runBenchmarkBaselineReportCliCommand as a6, runBenchmarkBaselineSnapshotCliCommand as a7, runBenchmarkCiGateCliCommand as a8, runBenchmarkImportCliCommand as a9, runMigrateObservationsCliCommand as aA, runMigrateRechunkCliCommand as aB, runMigrateReextractCliCommand as aC, runMigrateRescoreImportanceCliCommand as aD, runObjectiveStateStatusCliCommand as aE, runPolicyDiffCliCommand as aF, runPolicyRollbackCliCommand as aG, runPolicyStatusCliCommand as aH, runRebuildMemoryLifecycleLedgerCliCommand as aI, runRebuildMemoryProjectionCliCommand as aJ, runRebuildObservationsCliCommand as aK, runRepairMemoryProjectionCliCommand as aL, runReplayCliCommand as aM, runResumeBundleBuildCliCommand as aN, runResumeBundleRecordCliCommand as aO, runResumeBundleStatusCliCommand as aP, runRouteCliCommand as aQ, runSemanticRulePromoteCliCommand as aR, runSemanticRuleVerifyCliCommand as aS, runSessionCheckCliCommand as aT, runSessionRepairCliCommand as aU, runTailscaleStatusCliCommand as aV, runTailscaleSyncCliCommand as aW, runTierMigrateCliCommand as aX, runTierStatusCliCommand as aY, runTrainingExportCliCommand as aZ, runTrustZoneDemoSeedCliCommand as a_, runBenchmarkStatusCliCommand as aa, runBenchmarkStoredBaselineCiGateCliCommand as ab, runBenchmarkValidateCliCommand as ac, runCausalTrajectoryStatusCliCommand as ad, runCommitmentLifecycleCliCommand as ae, runCommitmentRecordCliCommand as af, runCommitmentSetStateCliCommand as ag, runCommitmentStatusCliCommand as ah, runCompatCliCommand as ai, runCompoundingPromoteCliCommand as aj, runConversationIndexHealthCliCommand as ak, runConversationIndexInspectCliCommand as al, runConversationIndexRebuildCliCommand as am, runCueAnchorStatusCliCommand as an, runDashboardStartCliCommand as ao, runDashboardStatusCliCommand as ap, runDashboardStopCliCommand as aq, runGraphHealthCliCommand as ar, runHarmonicSearchCliCommand as as, runMemoryActionAuditCliCommand as at, runMemoryGovernanceCliCommand as au, runMemoryGovernanceReportCliCommand as av, runMemoryGovernanceRestoreCliCommand as aw, runMemoryReviewDispositionCliCommand as ax, runMemoryTimelineCliCommand as ay, runMigrateNormalizeFrontmatterCliCommand as az, runBulkImportPipeline as b, runTrustZoneStatusCliCommand as b0, runUtilityLearningCliCommand as b1, runUtilityLearningStatusCliCommand as b2, runUtilityTelemetryRecordCliCommand as b3, runUtilityTelemetryStatusCliCommand as b4, runVerifiedRecallSearchCliCommand as b5, runVerifyMemoryProjectionCliCommand as b6, runWebDavServeCliCommand as b7, runWebDavStopCliCommand as b8, runWorkProductRecallSearchCliCommand as b9, runWorkProductRecordCliCommand as ba, runWorkProductStatusCliCommand as bb, runWorkProjectCliCommand as bc, runWorkTaskCliCommand as bd, 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 };