@remnic/core 1.1.12 → 1.1.13

package/dist/cli-D3VpkVwB.d.ts

@@ -0,0 +1,1136 @@
+import { CompoundingPromotionReport } from './compounding/engine.js';
+import { MigrateObservationsResult } from './maintenance/migrate-observations.js';
+import { MemoryGovernanceRunResult, MemoryGovernanceSummary, MemoryGovernanceMetrics, MemoryGovernanceQualityScore, MemoryGovernanceReviewQueueEntry, MemoryGovernanceAppliedAction, MemoryGovernanceTransitionReport, MemoryGovernanceManifest, MemoryGovernanceRestoreManifest, RestoreMemoryGovernanceRunResult } from './maintenance/memory-governance.js';
+import { MemoryStatus, MemoryFile, BehaviorSignalEvent, QmdSearchResult, MemoryActionEvent, MemoryLifecycleEvent } from './types.js';
+import { RebuildMemoryProjectionResult, RepairMemoryProjectionResult, VerifyMemoryProjectionResult } from './maintenance/rebuild-memory-projection.js';
+import { RebuildMemoryLifecycleLedgerResult } from './maintenance/rebuild-memory-lifecycle-ledger.js';
+import { RebuildObservationsResult } from './maintenance/rebuild-observations.js';
+import { ArchiveObservationsResult } from './maintenance/archive-observations.js';
+import { Writable, Readable } from 'node:stream';
+import { I as ImportTurn, B as BulkImportSource, a as BulkImportOptions, b as BulkImportResult, O as Orchestrator } from './orchestrator-DuWl9Hwx.js';
+import { ReplayRunSummary } from './replay/runner.js';
+import { ReplaySource, ReplayTurn } from './replay/types.js';
+import { WorkProjectStatus, WorkTaskStatus, WorkTaskPriority } from './work/types.js';
+import { RoutePatternType } from './routing/engine.js';
+import { TailscaleSyncOptions } from './network/tailscale.js';
+import { DashboardStatus } from './dashboard-runtime.js';
+import { E as EngramAccessService } from './access-service-DcCDmNYC.js';
+import { ResolveSecretRefFn } from './resolve-auth-token.js';
+import { CompatRunner, CompatReport } from './compat/types.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';
+import { C as ConnectorRunResult, a as ConnectorsOutputFormat } from './connectors-cli-CwbyjGR7.js';
+
+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;
+}
+interface ProcessBatchContext {
+    dedup: boolean;
+    trustLevel: "import";
+    namespace?: string;
+}
+type ProcessBatchFn = (turns: ImportTurn[], context: ProcessBatchContext) => 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>;
+
+/**
+ * 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 ConnectorsRunCliOutputOptions {
+    connectorId: string;
+    result: ConnectorRunResult;
+    format: ConnectorsOutputFormat;
+    stdout?: (output: string) => void;
+    stderr?: (output: string) => void;
+}
+interface DedupeCandidate {
+    path: string;
+    content: string;
+    frontmatter: {
+        id?: string;
+        confidence?: number;
+        updated?: string;
+        created?: string;
+    };
+}
+declare function emitConnectorsRunCliResult({ connectorId, result, format, stdout, stderr, }: ConnectorsRunCliOutputOptions): number;
+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 { parseDurationToMs as $, type AccessHttpServeCliCommandOptions as A, type BulkImportCliCommandOptions as B, type CompatCliCommandOptions as C, type DashboardStartCliCommandOptions as D, type ExactDedupePlan as E, type RepairMemoryProjectionCliCommandOptions as F, type GraphHealthCliCommandOptions as G, type ReplayCliCommandOptions as H, type ReplayCliOrchestrator as I, type RouteCliCommandOptions as J, type SessionRepairCliCommandOptions as K, type TailscaleSyncCliCommandOptions as L, type MemoryActionAuditCliCommandOptions as M, type TierMigrationCliOrchestrator as N, type TrainingExportCliCommandOptions as O, type ProcessBatchFn as P, type WorkProjectCliCommandOptions as Q, type RebuildMemoryLifecycleLedgerCliCommandOptions as R, type SessionIntegrityCliCommandOptions as S, type TailscaleStatusCliCommandOptions as T, type WorkTaskCliCommandOptions as U, type VerifyMemoryProjectionCliCommandOptions as V, type WebDavServeCliCommandOptions as W, emitConnectorsRunCliResult as X, filterNormalMemorySearchResults as Y, hasDestructivePurgeFailures as Z, isNormalRetrievalVisibleMemory as _, type ProcessBatchResult as a, runTailscaleStatusCliCommand as a$, parseStrictCliDate as a0, planAggressiveDuplicateDeletions as a1, planExactDuplicateDeletions as a2, registerCli as a3, resolveAccessPrincipalOverride as a4, resolveMemoryDirForNamespace as a5, runAbstractionNodeStatusCliCommand as a6, runAccessHttpServeCliCommand as a7, runAccessHttpStatusCliCommand as a8, runAccessHttpStopCliCommand as a9, runMemoryGovernanceCliCommand as aA, runMemoryGovernanceReportCliCommand as aB, runMemoryGovernanceRestoreCliCommand as aC, runMemoryReviewDispositionCliCommand as aD, runMemoryTimelineCliCommand as aE, runMigrateNormalizeFrontmatterCliCommand as aF, runMigrateObservationsCliCommand as aG, runMigrateRechunkCliCommand as aH, runMigrateReextractCliCommand as aI, runMigrateRescoreImportanceCliCommand as aJ, runObjectiveStateStatusCliCommand as aK, runPolicyDiffCliCommand as aL, runPolicyRollbackCliCommand as aM, runPolicyStatusCliCommand as aN, runRebuildMemoryLifecycleLedgerCliCommand as aO, runRebuildMemoryProjectionCliCommand as aP, runRebuildObservationsCliCommand as aQ, runRepairMemoryProjectionCliCommand as aR, runReplayCliCommand as aS, runResumeBundleBuildCliCommand as aT, runResumeBundleRecordCliCommand as aU, runResumeBundleStatusCliCommand as aV, runRouteCliCommand as aW, runSemanticRulePromoteCliCommand as aX, runSemanticRuleVerifyCliCommand as aY, runSessionCheckCliCommand as aZ, runSessionRepairCliCommand as a_, runAccessMcpServeCliCommand as aa, runArchiveObservationsCliCommand as ab, runBenchmarkBaselineReportCliCommand as ac, runBenchmarkBaselineSnapshotCliCommand as ad, runBenchmarkCiGateCliCommand as ae, runBenchmarkImportCliCommand as af, runBenchmarkStatusCliCommand as ag, runBenchmarkStoredBaselineCiGateCliCommand as ah, runBenchmarkValidateCliCommand as ai, runCausalTrajectoryStatusCliCommand as aj, runCommitmentLifecycleCliCommand as ak, runCommitmentRecordCliCommand as al, runCommitmentSetStateCliCommand as am, runCommitmentStatusCliCommand as an, runCompatCliCommand as ao, runCompoundingPromoteCliCommand as ap, runConversationIndexHealthCliCommand as aq, runConversationIndexInspectCliCommand as ar, runConversationIndexRebuildCliCommand as as, runCueAnchorStatusCliCommand as at, runDashboardStartCliCommand as au, runDashboardStatusCliCommand as av, runDashboardStopCliCommand as aw, runGraphHealthCliCommand as ax, runHarmonicSearchCliCommand as ay, runMemoryActionAuditCliCommand as az, runBulkImportPipeline as b, runTailscaleSyncCliCommand as b0, runTierMigrateCliCommand as b1, runTierStatusCliCommand as b2, runTrainingExportCliCommand as b3, runTrustZoneDemoSeedCliCommand as b4, runTrustZonePromoteCliCommand as b5, runTrustZoneStatusCliCommand as b6, runUtilityLearningCliCommand as b7, runUtilityLearningStatusCliCommand as b8, runUtilityTelemetryRecordCliCommand as b9, runUtilityTelemetryStatusCliCommand as ba, runVerifiedRecallSearchCliCommand as bb, runVerifyMemoryProjectionCliCommand as bc, runWebDavServeCliCommand as bd, runWebDavStopCliCommand as be, runWorkProductRecallSearchCliCommand as bf, runWorkProductRecordCliCommand as bg, runWorkProductStatusCliCommand as bh, runWorkProjectCliCommand as bi, runWorkTaskCliCommand as bj, type ArchiveObservationsCliCommandOptions as c, type ConnectorsRunCliOutputOptions as d, type ConversationIndexHealthCliOrchestrator as e, formatBatchTranscript as f, type DedupeCandidate as g, type MemoryActionAuditCliNamespaceSummary as h, type MemoryActionAuditCliReport as i, type MemoryGovernanceCliCommandOptions as j, type MemoryGovernanceReportCliCommandOptions as k, type MemoryGovernanceRestoreCliCommandOptions as l, type MemoryReviewDispositionCliCommandOptions as m, type MemoryTimelineCliCommandOptions as n, type MigrateCliOrchestrator as o, parseStrictCliDate$1 as p, type MigrateCliReport as q, runBulkImportCliCommand as r, type MigrateObservationsCliCommandOptions as s, type PolicyDiffCliReport as t, type PolicyDiffEntry as u, type PolicyRollbackCliReport as v, type PolicyStatusCliReport as w, type PolicyTuningCliOrchestrator as x, type RebuildMemoryProjectionCliCommandOptions as y, type RebuildObservationsCliCommandOptions as z };