opencode-lcm 0.12.0 → 0.13.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.1] - 2026-04-07
+
+### Fixed
+- Archive transform now removes malformed messages from the outbound message array before returning control to OpenCode, preventing follow-on backend `Bad Request` failures
+- Archive, resume, describe, search indexing, and capture paths now skip malformed `message.info` metadata defensively instead of throwing when required fields are missing
+
 ### Added
 - Opt-in `perf:archive` harness for large-archive regression coverage across transform, grep, snapshot, reopen, resume, and retention paths
 - Separate advisory `Archive Performance` workflow for scheduled/manual perf runs with JSON artifact upload

package/dist/store-doctor.d.ts

@@ -0,0 +1,73 @@
+import type { SqlDatabaseLike } from './store-types.js';
+/**
+ * Doctor diagnostics operations.
+ * Analyzes store health: summary graph integrity, FTS index consistency, orphan detection.
+ */
+export type DoctorSessionIssue = {
+    sessionID: string;
+    issues: string[];
+};
+export type DoctorReport = {
+    scope: string;
+    checkedSessions: number;
+    summarySessionsNeedingRebuild: DoctorSessionIssue[];
+    lineageSessionsNeedingRefresh: string[];
+    orphanSummaryEdges: number;
+    messageFts: {
+        expected: number;
+        actual: number;
+    };
+    summaryFts: {
+        expected: number;
+        actual: number;
+    };
+    artifactFts: {
+        expected: number;
+        actual: number;
+    };
+    orphanArtifactBlobs: number;
+    status: 'clean' | 'issues-found';
+};
+type SessionSnapshot = {
+    sessionID: string;
+    messages: {
+        info: {
+            id: string;
+            time: {
+                created: number;
+            };
+        };
+        parts: unknown[];
+    }[];
+    rootSessionID?: string;
+    lineageDepth?: number;
+};
+type SummaryNodeRow = {
+    node_id: string;
+    session_id: string;
+    level: number;
+    slot: number;
+    archived_message_ids_json: string;
+    summary_text: string;
+    created_at: number;
+};
+type DoctorDeps = {
+    db: SqlDatabaseLike;
+    getArchivedMessages: (messages: SessionSnapshot['messages']) => SessionSnapshot['messages'];
+    buildArchivedSignature: (messages: SessionSnapshot['messages']) => string;
+    readSummaryNode: (nodeID: string) => SummaryNodeRow | undefined;
+    canReuseSummaryGraph: (sessionID: string, archived: SessionSnapshot['messages'], roots: SummaryNodeRow[]) => boolean;
+    readScopedSummaryRows: (sessionIDs?: string[]) => unknown[];
+    readScopedArtifactRows: (sessionIDs?: string[]) => unknown[];
+    readOrphanArtifactBlobRows: () => unknown[];
+    countScopedFtsRows: (table: 'message_fts' | 'summary_fts' | 'artifact_fts', sessionIDs?: string[]) => number;
+    countScopedOrphanSummaryEdges: (sessionIDs?: string[]) => number;
+    guessMessageText: (message: SessionSnapshot['messages'][number], ignorePrefixes: string[]) => string;
+    ignoreToolPrefixes: string[];
+    parseJson: <T>(value: string) => T;
+};
+export declare function collectDoctorReport(sessions: SessionSnapshot[], sessionID: string | undefined, deps: DoctorDeps, readLineageChain: (sessionID: string) => {
+    sessionID: string;
+}[]): DoctorReport;
+export declare function hasDoctorIssues(report: DoctorReport): boolean;
+export {};

package/dist/store-doctor.js

@@ -0,0 +1,106 @@
+function countFtsExpected(sessions, deps) {
+    return sessions.reduce((count, session) => {
+        return (count +
+            session.messages.filter((message) => deps.guessMessageText(message, deps.ignoreToolPrefixes).length > 0).length);
+    }, 0);
+}
+function diagnoseSummarySession(session, deps) {
+    const issues = [];
+    const archived = deps.getArchivedMessages(session.messages);
+    const state = deps.db
+        .prepare('SELECT * FROM summary_state WHERE session_id = ?')
+        .get(session.sessionID);
+    const summaryNodeCount = deps.db
+        .prepare('SELECT COUNT(*) AS count FROM summary_nodes WHERE session_id = ?')
+        .get(session.sessionID);
+    const summaryEdgeCount = deps.db
+        .prepare('SELECT COUNT(*) AS count FROM summary_edges WHERE session_id = ?')
+        .get(session.sessionID);
+    if (archived.length === 0) {
+        if (state)
+            issues.push('unexpected-summary-state');
+        if (summaryNodeCount.count > 0)
+            issues.push('unexpected-summary-nodes');
+        if (summaryEdgeCount.count > 0)
+            issues.push('unexpected-summary-edges');
+        return issues.length > 0 ? { sessionID: session.sessionID, issues } : undefined;
+    }
+    const latestMessageCreated = archived.at(-1)?.info.time.created ?? 0;
+    const archivedSignature = deps.buildArchivedSignature(archived);
+    const rootIDs = state ? deps.parseJson(state.root_node_ids_json) : [];
+    const roots = rootIDs
+        .map((nodeID) => deps.readSummaryNode(nodeID))
+        .filter((node) => Boolean(node));
+    if (!state) {
+        issues.push('missing-summary-state');
+    }
+    else {
+        if (state.archived_count !== archived.length)
+            issues.push('archived-count-mismatch');
+        if (state.latest_message_created !== latestMessageCreated)
+            issues.push('latest-message-mismatch');
+        if (state.archived_signature !== archivedSignature)
+            issues.push('archived-signature-mismatch');
+        if (rootIDs.length === 0)
+            issues.push('missing-root-node-ids');
+        if (roots.length !== rootIDs.length) {
+            issues.push('missing-root-node-record');
+        }
+        else if (rootIDs.length > 0 &&
+            !deps.canReuseSummaryGraph(session.sessionID, archived, roots)) {
+            issues.push('invalid-summary-graph');
+        }
+    }
+    if (summaryNodeCount.count === 0)
+        issues.push('missing-summary-nodes');
+    return issues.length > 0 ? { sessionID: session.sessionID, issues } : undefined;
+}
+function needsLineageRefresh(session, readLineageChain) {
+    const chain = readLineageChain(session.sessionID);
+    const expectedRoot = chain[0]?.sessionID ?? session.sessionID;
+    const expectedDepth = Math.max(0, chain.length - 1);
+    return ((session.rootSessionID ?? session.sessionID) !== expectedRoot ||
+        (session.lineageDepth ?? 0) !== expectedDepth);
+}
+export function collectDoctorReport(sessions, sessionID, deps, readLineageChain) {
+    const sessionIDs = sessions.map((session) => session.sessionID);
+    const summarySessionsNeedingRebuild = sessions
+        .map((session) => diagnoseSummarySession(session, deps))
+        .filter((issue) => Boolean(issue));
+    const lineageSessionsNeedingRefresh = sessions
+        .filter((session) => needsLineageRefresh(session, readLineageChain))
+        .map((session) => session.sessionID);
+    const messageFtsExpected = countFtsExpected(sessions, deps);
+    const report = {
+        scope: sessionID ? `session:${sessionID}` : 'all',
+        checkedSessions: sessions.length,
+        summarySessionsNeedingRebuild,
+        lineageSessionsNeedingRefresh,
+        orphanSummaryEdges: deps.countScopedOrphanSummaryEdges(sessionIDs),
+        messageFts: {
+            expected: messageFtsExpected,
+            actual: deps.countScopedFtsRows('message_fts', sessionIDs),
+        },
+        summaryFts: {
+            expected: deps.readScopedSummaryRows(sessionIDs).length,
+            actual: deps.countScopedFtsRows('summary_fts', sessionIDs),
+        },
+        artifactFts: {
+            expected: deps.readScopedArtifactRows(sessionIDs).length,
+            actual: deps.countScopedFtsRows('artifact_fts', sessionIDs),
+        },
+        orphanArtifactBlobs: deps.readOrphanArtifactBlobRows().length,
+        status: 'clean',
+    };
+    report.status = hasDoctorIssues(report) ? 'issues-found' : 'clean';
+    return report;
+}
+export function hasDoctorIssues(report) {
+    return (report.summarySessionsNeedingRebuild.length > 0 ||
+        report.lineageSessionsNeedingRefresh.length > 0 ||
+        report.orphanSummaryEdges > 0 ||
+        report.messageFts.expected !== report.messageFts.actual ||
+        report.summaryFts.expected !== report.summaryFts.actual ||
+        report.artifactFts.expected !== report.artifactFts.actual ||
+        report.orphanArtifactBlobs > 0);
+}

package/dist/store-schema.d.ts

@@ -0,0 +1,8 @@
+import type { SqlDatabaseLike } from './store-types.js';
+/**
+ * Schema version management operations.
+ * Handles reading, writing, and validating the SQLite store schema version.
+ */
+export declare function readSchemaVersionSync(db: SqlDatabaseLike): number;
+export declare function assertSupportedSchemaVersionSync(db: SqlDatabaseLike, maxVersion: number): void;
+export declare function writeSchemaVersionSync(db: SqlDatabaseLike, version: number): void;

package/dist/store-schema.js

@@ -0,0 +1,23 @@
+/**
+ * Schema version management operations.
+ * Handles reading, writing, and validating the SQLite store schema version.
+ */
+export function readSchemaVersionSync(db) {
+    const result = db.prepare('PRAGMA user_version').get();
+    if (!result || typeof result !== 'object')
+        return 0;
+    for (const value of Object.values(result)) {
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+    }
+    return 0;
+}
+export function assertSupportedSchemaVersionSync(db, maxVersion) {
+    const schemaVersion = readSchemaVersionSync(db);
+    if (schemaVersion <= maxVersion)
+        return;
+    throw new Error(`Unsupported store schema version: ${schemaVersion}. This build supports up to ${maxVersion}.`);
+}
+export function writeSchemaVersionSync(db, version) {
+    db.exec(`PRAGMA user_version = ${Math.max(0, Math.trunc(version))}`);
+}

package/dist/store-session-read.d.ts

@@ -0,0 +1,97 @@
+import type { SqlDatabaseLike } from './store-types.js';
+/**
+ * Session read operations.
+ * Handles reading sessions, messages, parts, artifacts from the store.
+ */
+export type SessionRow = {
+    session_id: string;
+    title: string | null;
+    parent_session_id: string | null;
+    root_session_id: string | null;
+    lineage_depth: number | null;
+    session_directory: string | null;
+    worktree_key: string | null;
+    pinned: number;
+    pin_reason: string | null;
+    deleted: number;
+    updated_at: number;
+    created_at: number;
+    event_count: number;
+};
+export type MessageRow = {
+    session_id: string;
+    message_id: string;
+    role: string;
+    created_at: number;
+};
+export type PartRow = {
+    session_id: string;
+    message_id: string;
+    part_id: string;
+    part_type: string;
+    sort_key: number;
+    state_json: string;
+    created_at: number;
+};
+export type ArtifactRow = {
+    artifact_id: string;
+    session_id: string;
+    message_id: string;
+    part_id: string;
+    artifact_kind: string;
+    field_name: string;
+    content_hash: string | null;
+    preview_text: string;
+    metadata_json: string;
+    char_count: number;
+    created_at: number;
+};
+export type ArtifactBlobRow = {
+    content_hash: string;
+    content_text: string;
+    char_count: number;
+    created_at: number;
+};
+export type SummaryNodeRow = {
+    node_id: string;
+    session_id: string;
+    level: number;
+    slot: number;
+    archived_message_ids_json: string;
+    summary_text: string;
+    created_at: number;
+};
+export type SummaryEdgeRow = {
+    session_id: string;
+    parent_id: string;
+    child_id: string;
+    child_position: number;
+};
+export type SummaryStateRow = {
+    session_id: string;
+    archived_count: number;
+    latest_message_created: number;
+    archived_signature: string;
+    root_node_ids_json: string;
+    updated_at: number;
+};
+export declare function readSessionHeader(db: SqlDatabaseLike, sessionID: string): SessionRow | undefined;
+export declare function readAllSessions(db: SqlDatabaseLike): SessionRow[];
+export declare function readChildSessions(db: SqlDatabaseLike, parentSessionID: string): SessionRow[];
+export declare function readLineageChain(db: SqlDatabaseLike, sessionID: string): SessionRow[];
+export declare function readMessagesForSession(db: SqlDatabaseLike, sessionID: string): MessageRow[];
+export declare function readPartsForSession(db: SqlDatabaseLike, sessionID: string): PartRow[];
+export declare function readArtifactsForSession(db: SqlDatabaseLike, sessionID: string): ArtifactRow[];
+export declare function readArtifact(db: SqlDatabaseLike, artifactID: string): ArtifactRow | undefined;
+export declare function readArtifactBlob(db: SqlDatabaseLike, contentHash: string): ArtifactBlobRow | undefined;
+export declare function readOrphanArtifactBlobRows(db: SqlDatabaseLike): ArtifactBlobRow[];
+export declare function readLatestSessionID(db: SqlDatabaseLike): string | undefined;
+export declare function readSessionStats(db: SqlDatabaseLike): {
+    sessionCount: number;
+    messageCount: number;
+    artifactCount: number;
+    summaryNodeCount: number;
+    blobCount: number;
+    orphanBlobCount: number;
+    orphanBlobChars: number;
+};

package/dist/store-session-read.js

@@ -0,0 +1,80 @@
+export function readSessionHeader(db, sessionID) {
+    return db.prepare('SELECT * FROM sessions WHERE session_id = ?').get(sessionID);
+}
+export function readAllSessions(db) {
+    return db.prepare('SELECT * FROM sessions ORDER BY updated_at DESC').all();
+}
+export function readChildSessions(db, parentSessionID) {
+    return db
+        .prepare('SELECT * FROM sessions WHERE parent_session_id = ? ORDER BY updated_at DESC')
+        .all(parentSessionID);
+}
+export function readLineageChain(db, sessionID) {
+    const chain = [];
+    let current = readSessionHeader(db, sessionID);
+    while (current) {
+        chain.unshift(current);
+        if (!current.parent_session_id)
+            break;
+        current = readSessionHeader(db, current.parent_session_id);
+    }
+    return chain;
+}
+export function readMessagesForSession(db, sessionID) {
+    return db
+        .prepare('SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC')
+        .all(sessionID);
+}
+export function readPartsForSession(db, sessionID) {
+    return db
+        .prepare('SELECT * FROM parts WHERE session_id = ? ORDER BY message_id ASC, sort_key ASC')
+        .all(sessionID);
+}
+export function readArtifactsForSession(db, sessionID) {
+    return db
+        .prepare('SELECT * FROM artifacts WHERE session_id = ? ORDER BY created_at DESC')
+        .all(sessionID);
+}
+export function readArtifact(db, artifactID) {
+    return db.prepare('SELECT * FROM artifacts WHERE artifact_id = ?').get(artifactID);
+}
+export function readArtifactBlob(db, contentHash) {
+    return db.prepare('SELECT * FROM artifact_blobs WHERE content_hash = ?').get(contentHash);
+}
+export function readOrphanArtifactBlobRows(db) {
+    return db
+        .prepare(`SELECT b.* FROM artifact_blobs b
+       WHERE NOT EXISTS (
+         SELECT 1 FROM artifacts a WHERE a.content_hash = b.content_hash
+       )
+       ORDER BY b.created_at ASC`)
+        .all();
+}
+export function readLatestSessionID(db) {
+    const row = db
+        .prepare('SELECT session_id FROM sessions ORDER BY updated_at DESC LIMIT 1')
+        .get();
+    return row?.session_id;
+}
+export function readSessionStats(db) {
+    const sessions = db.prepare('SELECT COUNT(*) AS count FROM sessions').get();
+    const messages = db.prepare('SELECT COUNT(*) AS count FROM messages').get();
+    const artifacts = db.prepare('SELECT COUNT(*) AS count FROM artifacts').get();
+    const summaryNodes = db.prepare('SELECT COUNT(*) AS count FROM summary_nodes').get();
+    const blobs = db
+        .prepare(`SELECT COUNT(*) AS count, COALESCE(SUM(char_count), 0) AS chars
+       FROM artifact_blobs b
+       WHERE NOT EXISTS (
+         SELECT 1 FROM artifacts a WHERE a.content_hash = b.content_hash
+       )`)
+        .get();
+    return {
+        sessionCount: sessions.count,
+        messageCount: messages.count,
+        artifactCount: artifacts.count,
+        summaryNodeCount: summaryNodes.count,
+        blobCount: blobs.count,
+        orphanBlobCount: blobs.count,
+        orphanBlobChars: blobs.chars,
+    };
+}

package/dist/store.d.ts

@@ -95,11 +95,17 @@ export declare class SqliteLcmStore {
     private readonly workspaceDirectory;
     private db?;
     private dbReadyPromise?;
+    private deferredInitTimer?;
+    private deferredInitPromise?;
+    private deferredInitRequested;
+    private activeOperationCount;
     private readonly pendingPartUpdates;
     private pendingPartUpdateTimer?;
     private pendingPartUpdateFlushPromise?;
     constructor(projectDir: string, options: OpencodeLcmOptions);
     init(): Promise<void>;
+    private withStoreActivity;
+    private waitForDeferredInitIfRunning;
     private prepareForRead;
     private scheduleDeferredPartUpdateFlush;
     private clearDeferredPartUpdateTimer;
@@ -111,6 +117,9 @@ export declare class SqliteLcmStore {
     private ensureDbReady;
     private openAndInitializeDb;
     private deferredInitCompleted;
+    private runDeferredInit;
+    private scheduleDeferredInit;
+    private ensureDeferredInitComplete;
     private readSchemaVersionSync;
     private assertSupportedSchemaVersionSync;
     private writeSchemaVersionSync;
@@ -239,6 +248,8 @@ export declare class SqliteLcmStore {
     buildCompactionContext(sessionID: string): Promise<string | undefined>;
     transformMessages(messages: ConversationMessage[]): Promise<boolean>;
     systemHint(): string | undefined;
+    private sanitizeSessionMessages;
+    private shouldSkipMalformedCapturedEvent;
     private buildAutomaticRetrievalContext;
     private buildAutomaticRetrievalQuery;
     private buildAutomaticRetrievalQueries;
@@ -289,6 +300,7 @@ export declare class SqliteLcmStore {
     private resolveLineageSync;
     private applyEvent;
     private getResumeSync;
+    private materializeSessionRow;
     private readSessionHeaderSync;
     private clearSessionDataSync;
     private readChildSessionsSync;