@remnic/core 1.0.0

package/dist/objective-state.d.ts

@@ -0,0 +1,75 @@
+type ObjectiveStateSnapshotSource = "tool_result" | "cli" | "system" | "manual";
+type ObjectiveStateSnapshotKind = "tool" | "file" | "process" | "record" | "workspace";
+type ObjectiveStateChangeKind = "created" | "updated" | "deleted" | "observed" | "executed" | "failed";
+type ObjectiveStateOutcome = "success" | "failure" | "partial" | "unknown";
+interface ObjectiveStateValueRef {
+    exists?: boolean;
+    ref?: string;
+    valueHash?: string;
+}
+interface ObjectiveStateSnapshot {
+    schemaVersion: 1;
+    snapshotId: string;
+    recordedAt: string;
+    sessionKey: string;
+    source: ObjectiveStateSnapshotSource;
+    kind: ObjectiveStateSnapshotKind;
+    changeKind: ObjectiveStateChangeKind;
+    scope: string;
+    summary: string;
+    toolName?: string;
+    command?: string;
+    outcome?: ObjectiveStateOutcome;
+    before?: ObjectiveStateValueRef;
+    after?: ObjectiveStateValueRef;
+    entityRefs?: string[];
+    tags?: string[];
+    metadata?: Record<string, string>;
+}
+interface ObjectiveStateStoreStatus {
+    enabled: boolean;
+    writesEnabled: boolean;
+    rootDir: string;
+    snapshotsDir: string;
+    snapshots: {
+        total: number;
+        valid: number;
+        invalid: number;
+        byKind: Partial<Record<ObjectiveStateSnapshotKind, number>>;
+        byOutcome: Partial<Record<ObjectiveStateOutcome, number>>;
+        latestSnapshotId?: string;
+        latestRecordedAt?: string;
+        latestSessionKey?: string;
+    };
+    latestSnapshot?: ObjectiveStateSnapshot;
+    invalidSnapshots: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+interface ObjectiveStateSearchResult {
+    snapshot: ObjectiveStateSnapshot;
+    score: number;
+}
+declare function resolveObjectiveStateStoreDir(memoryDir: string, overrideDir?: string): string;
+declare function validateObjectiveStateSnapshot(raw: unknown): ObjectiveStateSnapshot;
+declare function recordObjectiveStateSnapshot(options: {
+    memoryDir: string;
+    objectiveStateStoreDir?: string;
+    snapshot: ObjectiveStateSnapshot;
+}): Promise<string>;
+declare function getObjectiveStateStoreStatus(options: {
+    memoryDir: string;
+    objectiveStateStoreDir?: string;
+    enabled: boolean;
+    writesEnabled: boolean;
+}): Promise<ObjectiveStateStoreStatus>;
+declare function searchObjectiveStateSnapshots(options: {
+    memoryDir: string;
+    objectiveStateStoreDir?: string;
+    query: string;
+    maxResults: number;
+    sessionKey?: string;
+}): Promise<ObjectiveStateSearchResult[]>;
+
+export { type ObjectiveStateChangeKind, type ObjectiveStateOutcome, type ObjectiveStateSearchResult, type ObjectiveStateSnapshot, type ObjectiveStateSnapshotKind, type ObjectiveStateSnapshotSource, type ObjectiveStateStoreStatus, type ObjectiveStateValueRef, getObjectiveStateStoreStatus, recordObjectiveStateSnapshot, resolveObjectiveStateStoreDir, searchObjectiveStateSnapshots, validateObjectiveStateSnapshot };

package/dist/objective-state.js

@@ -0,0 +1,17 @@
+import {
+  getObjectiveStateStoreStatus,
+  recordObjectiveStateSnapshot,
+  resolveObjectiveStateStoreDir,
+  searchObjectiveStateSnapshots,
+  validateObjectiveStateSnapshot
+} from "./chunk-LOBRX7VD.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+export {
+  getObjectiveStateStoreStatus,
+  recordObjectiveStateSnapshot,
+  resolveObjectiveStateStoreDir,
+  searchObjectiveStateSnapshots,
+  validateObjectiveStateSnapshot
+};
+//# sourceMappingURL=objective-state.js.map

package/dist/objective-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/openai-chat-compat.d.ts

@@ -0,0 +1,13 @@
+declare function shouldAssumeOpenAiChatCompletions(baseUrl?: string): boolean;
+declare function usesMaxCompletionTokens(model: string, options?: {
+    assumeOpenAI?: boolean;
+}): boolean;
+declare function buildChatCompletionTokenLimit(model: string, maxTokens: number, options?: {
+    assumeOpenAI?: boolean;
+}): {
+    max_tokens: number;
+} | {
+    max_completion_tokens: number;
+};
+
+export { buildChatCompletionTokenLimit, shouldAssumeOpenAiChatCompletions, usesMaxCompletionTokens };

package/dist/openai-chat-compat.js

@@ -0,0 +1,11 @@
+import {
+  buildChatCompletionTokenLimit,
+  shouldAssumeOpenAiChatCompletions,
+  usesMaxCompletionTokens
+} from "./chunk-Y27UJK6V.js";
+export {
+  buildChatCompletionTokenLimit,
+  shouldAssumeOpenAiChatCompletions,
+  usesMaxCompletionTokens
+};
+//# sourceMappingURL=openai-chat-compat.js.map

package/dist/openai-chat-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/operator-toolkit.d.ts

@@ -0,0 +1,304 @@
+import { EvalHarnessStatus, validateEvalBenchmarkPack, EvalBaselineDeltaReport, EvalCiGateReport } from './evals.js';
+import { GraphHealthReport } from './graph.js';
+import { SessionIntegrityReport, SessionRepairPlan, SessionRepairApplyResult } from './session-integrity.js';
+import { PluginConfig } from './types.js';
+
+interface QmdRuntimeLike {
+    probe(): Promise<boolean>;
+    isAvailable(): boolean;
+    ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+    debugStatus(): string;
+}
+interface ConversationIndexLike {
+    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;
+            };
+        };
+    }>;
+    rebuildConversationIndex(sessionKey?: string, hours?: number, opts?: {
+        embed?: boolean;
+    }): Promise<{
+        chunks: number;
+        skipped: boolean;
+        reason?: string;
+        embedded?: boolean;
+        rebuilt?: boolean;
+    }>;
+}
+interface OperatorToolkitOrchestrator extends ConversationIndexLike {
+    config: PluginConfig;
+    qmd: QmdRuntimeLike;
+}
+interface OperatorConfigLoadResult {
+    found: boolean;
+    path: string;
+    parsed: boolean;
+    memoryDir?: string;
+    workspaceDir?: string;
+    error?: string;
+}
+interface OperatorSetupReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    config: OperatorConfigLoadResult;
+    memoryDir: string;
+    workspaceDir: string;
+    directories: Array<{
+        path: string;
+        exists: boolean;
+        writable: boolean;
+    }>;
+    qmd: {
+        enabled: boolean;
+        available: boolean;
+        collectionState: "present" | "missing" | "unknown" | "skipped";
+        debugStatus: string;
+    };
+    nativeKnowledge: {
+        enabled: boolean;
+        includeFiles: string[];
+        curatedIncludeSync: {
+            statePath: string;
+            exists: boolean;
+            updatedAt: string | null;
+            fileCount: number;
+            activeChunkCount: number;
+            deletedFileCount: number;
+        };
+        openclawWorkspaceAdapterEnabled: boolean;
+        obsidianVaultAdapterEnabled: boolean;
+        obsidianSync: {
+            statePath: string;
+            exists: boolean;
+            updatedAt: string | null;
+            vaultCount: number;
+            activeChunkCount: number;
+            deletedNoteCount: number;
+        };
+        openclawWorkspaceSync: {
+            statePath: string;
+            exists: boolean;
+            updatedAt: string | null;
+            fileCount: number;
+            activeChunkCount: number;
+            deletedFileCount: number;
+        };
+    };
+    explicitCapture: {
+        captureMode: string;
+        enabled: boolean;
+        memoryDocPath: string;
+        memoryDocExists: boolean;
+        memoryDocInstalled: boolean;
+        memoryDocUpdated: boolean;
+        memoryDocRemoved: boolean;
+        preview: string | null;
+    };
+    nextSteps: string[];
+    verificationCommands: string[];
+}
+interface OperatorDoctorCheck {
+    key: string;
+    status: "ok" | "warn" | "error";
+    summary: string;
+    remediation?: string;
+    details?: unknown;
+}
+interface OperatorConfigReviewFinding {
+    key: string;
+    status: "recommend" | "problem";
+    setting: string;
+    currentValue: string;
+    defaultValue: string;
+    recommendedValue: string;
+    summary: string;
+    rationale: string;
+}
+interface OperatorConfigReviewReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    ok: boolean;
+    config: OperatorConfigLoadResult;
+    profile: {
+        memoryOsPreset?: string;
+        searchBackend: string;
+        qmdEnabled: boolean;
+        qmdDaemonEnabled: boolean;
+        nativeKnowledgeEnabled: boolean;
+        fileHygieneEnabled: boolean;
+        conversationIndexEnabled: boolean;
+    };
+    summary: {
+        recommend: number;
+        problem: number;
+    };
+    findings: OperatorConfigReviewFinding[];
+}
+interface OperatorDoctorReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    ok: boolean;
+    summary: {
+        ok: number;
+        warn: number;
+        error: number;
+    };
+    config: OperatorConfigLoadResult;
+    checks: OperatorDoctorCheck[];
+}
+interface OperatorInventoryNamespaceSummary {
+    namespace: string;
+    memoryCount: number;
+    entityCount: number;
+}
+interface OperatorInventoryReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    memoryDir: string;
+    totals: {
+        memories: number;
+        entities: number;
+        namespaces: number;
+        reviewQueue: number;
+        storageBytes: number;
+    };
+    categories: Record<string, number>;
+    statuses: Record<string, number>;
+    namespaces: OperatorInventoryNamespaceSummary[];
+    ageBands: Record<string, number>;
+    profile: {
+        exists: boolean;
+        chars: number;
+        lines: number;
+    };
+    storageFootprint: {
+        bytes: number;
+        byTopLevel: Record<string, number>;
+    };
+    archivePressure: {
+        archived: number;
+        pendingReview: number;
+        quarantined: number;
+        rejected: number;
+    };
+    conversationIndex: {
+        enabled: boolean;
+        backend: "qmd" | "faiss";
+        status: "ok" | "degraded" | "disabled";
+        chunkDocCount: number;
+        lastUpdateAt: string | null;
+    };
+    nativeKnowledge: {
+        enabled: boolean;
+        curatedIncludeSync: {
+            exists: boolean;
+            updatedAt: string | null;
+            fileCount: number;
+            activeChunkCount: number;
+            deletedFileCount: number;
+        };
+        obsidianSync: {
+            exists: boolean;
+            updatedAt: string | null;
+            vaultCount: number;
+            activeChunkCount: number;
+            deletedNoteCount: number;
+        };
+        openclawWorkspaceSync: {
+            exists: boolean;
+            updatedAt: string | null;
+            fileCount: number;
+            activeChunkCount: number;
+            deletedFileCount: number;
+        };
+    };
+}
+interface BenchmarkRecallReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    mode: "status" | "validate" | "baseline-report" | "ci-gate" | "snapshot";
+    status: EvalHarnessStatus;
+    validate?: Awaited<ReturnType<typeof validateEvalBenchmarkPack>>;
+    baselineReport?: EvalBaselineDeltaReport;
+    ciGate?: EvalCiGateReport;
+    snapshot?: {
+        targetPath: string;
+        snapshotId: string;
+    };
+}
+interface OperatorRepairReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    dryRun: boolean;
+    sessionCheck: SessionIntegrityReport;
+    sessionRepairPlan: SessionRepairPlan;
+    sessionRepairApply: SessionRepairApplyResult;
+    graphHealth: GraphHealthReport;
+}
+interface OperatorSetupOptions {
+    orchestrator: OperatorToolkitOrchestrator;
+    installCaptureInstructions?: boolean;
+    captureInstructionsMode?: "preview" | "install" | "remove";
+    configPath?: string;
+    now?: Date;
+}
+interface OperatorDoctorOptions {
+    orchestrator: OperatorToolkitOrchestrator;
+    configPath?: string;
+    now?: Date;
+}
+interface OperatorConfigReviewOptions {
+    orchestrator: OperatorToolkitOrchestrator;
+    configPath?: string;
+    now?: Date;
+}
+interface OperatorInventoryOptions {
+    orchestrator: OperatorToolkitOrchestrator;
+    now?: Date;
+}
+interface BenchmarkRecallOptions {
+    config: Pick<PluginConfig, "memoryDir" | "evalStoreDir" | "evalHarnessEnabled" | "evalShadowModeEnabled" | "benchmarkBaselineSnapshotsEnabled" | "benchmarkDeltaReporterEnabled" | "memoryRedTeamBenchEnabled">;
+    validatePath?: string;
+    baseEvalStoreDir?: string;
+    candidateEvalStoreDir?: string;
+    snapshotId?: string;
+    createSnapshot?: boolean;
+    snapshotNotes?: string;
+    gitRef?: string;
+    createdAt?: string;
+    now?: Date;
+}
+interface OperatorRepairOptions {
+    config: Pick<PluginConfig, "memoryDir" | "entityGraphEnabled" | "timeGraphEnabled" | "causalGraphEnabled">;
+    apply?: boolean;
+    dryRun?: boolean;
+    allowSessionFileRepair?: boolean;
+    sessionFilesDir?: string;
+    now?: Date;
+}
+declare function runOperatorSetup(options: OperatorSetupOptions): Promise<OperatorSetupReport>;
+declare function runOperatorConfigReview(options: OperatorConfigReviewOptions): Promise<OperatorConfigReviewReport>;
+declare function runOperatorDoctor(options: OperatorDoctorOptions): Promise<OperatorDoctorReport>;
+declare function runOperatorInventory(options: OperatorInventoryOptions): Promise<OperatorInventoryReport>;
+declare function runBenchmarkRecall(options: BenchmarkRecallOptions): Promise<BenchmarkRecallReport>;
+declare function runOperatorRepair(options: OperatorRepairOptions): Promise<OperatorRepairReport>;
+
+export { type BenchmarkRecallOptions, type BenchmarkRecallReport, type OperatorConfigLoadResult, type OperatorConfigReviewFinding, type OperatorConfigReviewOptions, type OperatorConfigReviewReport, type OperatorDoctorCheck, type OperatorDoctorOptions, type OperatorDoctorReport, type OperatorInventoryNamespaceSummary, type OperatorInventoryOptions, type OperatorInventoryReport, type OperatorRepairOptions, type OperatorRepairReport, type OperatorSetupOptions, type OperatorSetupReport, type OperatorToolkitOrchestrator, runBenchmarkRecall, runOperatorConfigReview, runOperatorDoctor, runOperatorInventory, runOperatorRepair, runOperatorSetup };

package/dist/operator-toolkit.js

@@ -0,0 +1,41 @@
+import {
+  runBenchmarkRecall,
+  runOperatorConfigReview,
+  runOperatorDoctor,
+  runOperatorInventory,
+  runOperatorRepair,
+  runOperatorSetup
+} from "./chunk-QDOSNLB4.js";
+import "./chunk-IZME7KW2.js";
+import "./chunk-YRMVARQP.js";
+import "./chunk-TVVVQQAK.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-Q6FETXJA.js";
+import "./chunk-K6WK37A6.js";
+import "./chunk-SCHEKPYH.js";
+import "./chunk-ISY75RLM.js";
+import "./chunk-Z5LAYHGJ.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-J3BT33K7.js";
+import "./chunk-QWUUMMIK.js";
+import "./chunk-U4PV25RD.js";
+import "./chunk-ESSMF2FR.js";
+import "./chunk-TP4FZJIZ.js";
+import "./chunk-SCU65EZI.js";
+import "./chunk-BOUYNNYD.js";
+import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
+import "./chunk-HLXVTBF3.js";
+import "./chunk-M62O4P4T.js";
+import "./chunk-KWBU5S5U.js";
+import "./chunk-LPSF4OQH.js";
+import "./chunk-QCCCQT3O.js";
+export {
+  runBenchmarkRecall,
+  runOperatorConfigReview,
+  runOperatorDoctor,
+  runOperatorInventory,
+  runOperatorRepair,
+  runOperatorSetup
+};
+//# sourceMappingURL=operator-toolkit.js.map

package/dist/operator-toolkit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/opik-exporter.d.ts

@@ -0,0 +1,72 @@
+import { LoggerBackend } from './logger.js';
+
+interface OpikExporterConfig {
+    enabled: boolean;
+    /** Base URL of the Opik API, e.g. http://192.168.3.147:5173/api */
+    apiUrl: string;
+    projectName: string;
+    workspaceName: string;
+    /** Optional API key (not required for self-hosted deployments) */
+    apiKey?: string;
+    /** Include recalled memory text in spans (default false) */
+    traceRecallContent: boolean;
+}
+declare class OpikExporter {
+    private readonly cfg;
+    private readonly log;
+    private _handler;
+    private readonly inFlight;
+    /** Track which trace_ids we have already created parent trace objects for. */
+    private readonly createdTraces;
+    /** In-flight ensureTrace promises keyed by traceId — concurrent callers await the same promise. */
+    private readonly pendingTraces;
+    /** TTL for in-flight LLM entries (ms). Entries older than this are discarded. */
+    private static readonly IN_FLIGHT_TTL_MS;
+    constructor(cfg: OpikExporterConfig, log: LoggerBackend);
+    /**
+     * Subscribe to Engram's global trace slot. Safe to call multiple times —
+     * chains with existing subscribers (e.g. Langfuse) rather than replacing.
+     */
+    subscribe(): void;
+    /** Deactivate this exporter instance.
+     *
+     * We intentionally do NOT restore __openclawEngramTrace to a prior handler
+     * because any subscriber that chained *after* us would be silently dropped
+     * by such a restoration. Instead we mark the instance as disabled so that
+     * handleEvent() becomes a no-op while the callback chain itself is left
+     * untouched. The next subscribe() call from a fresh instance will re-enter
+     * the chain on top of whatever is there at that point.
+     */
+    _detach(): void;
+    unsubscribe(): void;
+    private handleEvent;
+    private onRecall;
+    private onLlmStart;
+    private sweepStaleInFlight;
+    private onLlmEnd;
+    /**
+     * Create a parent trace object in Opik if we haven't already.
+     * Opik does NOT auto-create traces from spans, so without this
+     * the spans are orphaned and don't show up in the trace list UI.
+     */
+    private ensureTrace;
+    /**
+     * Convert a sessionKey to a stable, deterministic UUID v7-shaped ID so that
+     * spans for the same session share a trace_id and are threaded in Opik.
+     * Uses SHA-256 for collision resistance. The timestamp bytes (0-5) come from
+     * the hash itself — they don't reflect real time, but Opik only validates
+     * the version/variant bits, not timestamp ordering.
+     */
+    private sessionToTraceId;
+}
+interface OpikExporterRawConfig {
+    opikTraceEnabled?: boolean;
+    opikApiUrl?: string;
+    opikProjectName?: string;
+    opikWorkspaceName?: string;
+    opikApiKey?: string;
+    opikTraceRecallContent?: boolean;
+}
+declare function createOpikExporter(raw: OpikExporterRawConfig, log: LoggerBackend): OpikExporter | null;
+
+export { OpikExporter, type OpikExporterConfig, type OpikExporterRawConfig, createOpikExporter };