om-memory-system 3.1.1 → 3.2.0-next.11

package/dist/services/ai/providers/anthropic-messages.js

@@ -1,4 +1,4 @@
-import { applySafeExtraParams, BaseAIProvider } from "./base-provider.js";
+import { applySafeExtraParams, BaseAIProvider, describeValidationError, } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { ToolSchemaConverter } from "../tools/tool-schema.js";
 import { log } from "../../logger.js";
@@ -48,6 +48,8 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
         return "Anthropic API request timeout";
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         const providerTag = this.sessionProviderTag();
         let session = await this.aiSessionManager.getSession(sessionId, providerTag);
         if (!session) {
@@ -119,12 +121,14 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                         iteration: iterations,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `API error: ${response.status} - ${errorText}`,
                         iterations,
                     };
                 }
                 const data = (await response.json());
+                stopReason = data.stop_reason;
                 const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
                 await this.aiSessionManager.addMessage({
                     aiSessionId: session.id,
@@ -145,26 +149,27 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                             throw new Error(result.errors.join(", "));
                         }
                         return {
+                            stopReason,
                             success: true,
                             data: result.data,
                             iterations,
                         };
                     }
                     catch (validationError) {
-                        const errorStack = validationError instanceof Error ? validationError.stack : undefined;
                         log(this.toolValidationErrorLogLabel(), {
-                            error: String(validationError),
-                            stack: errorStack,
+                            error: describeValidationError(validationError),
                             errorType: validationError instanceof Error
                                 ? validationError.constructor.name
                                 : typeof validationError,
                             toolName: toolSchema.function.name,
                             iteration: iterations,
-                            rawData: JSON.stringify(toolUse).slice(0, 500),
+                            // Log only the size: the tool input is the model's reply.
+                            inputChars: JSON.stringify(toolUse)?.length ?? 0,
                         });
                         return {
+                            stopReason,
                             success: false,
-                            error: `Validation failed: ${String(validationError)}`,
+                            error: `Validation failed: ${describeValidationError(validationError)}`,
                             iterations,
                         };
                     }
@@ -188,12 +193,14 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
                 clearTimeout(timeout);
                 if (error instanceof Error && error.name === "AbortError") {
                     return {
+                        stopReason,
                         success: false,
                         error: `${this.timeoutLabel()} (${this.config.iterationTimeout}ms)`,
                         iterations,
                     };
                 }
                 return {
+                    stopReason,
                     success: false,
                     error: String(error),
                     iterations,
@@ -201,6 +208,7 @@ export class AnthropicMessagesProvider extends BaseAIProvider {
             }
         }
         return {
+            stopReason,
             success: false,
             error: `Max iterations (${maxIterations}) reached without tool use`,
             iterations,

package/dist/services/ai/providers/base-provider.d.ts

@@ -3,6 +3,8 @@ export interface ToolCallResult {
     data?: any;
     error?: string;
     iterations?: number;
+    /** The provider's last reported stop reason, e.g. a length limit. */
+    stopReason?: string;
 }
 export interface ProviderConfig {
     model: string;
@@ -14,6 +16,12 @@ export interface ProviderConfig {
     memoryTemperature?: number | false;
     extraParams?: Record<string, unknown>;
 }
+/**
+ * A validation error message that is safe to log and return. A JSON
+ * `SyntaxError` message quotes the start of the model's reply, which can carry
+ * conversation content, so it is replaced; validator messages name fields only.
+ */
+export declare function describeValidationError(error: unknown): string;
 export declare function applySafeExtraParams(requestBody: Record<string, any>, extraParams: Record<string, unknown>): void;
 export declare abstract class BaseAIProvider {
     protected config: ProviderConfig;

package/dist/services/ai/providers/base-provider.js

@@ -1,3 +1,15 @@
+/**
+ * A validation error message that is safe to log and return. A JSON
+ * `SyntaxError` message quotes the start of the model's reply, which can carry
+ * conversation content, so it is replaced; validator messages name fields only.
+ */
+export function describeValidationError(error) {
+    if (error instanceof SyntaxError)
+        return "tool arguments are not valid JSON";
+    if (error instanceof Error)
+        return error.message;
+    return "unknown validation error";
+}
 const PROTECTED_KEYS = new Set([
     "model",
     "messages",

package/dist/services/ai/providers/google-gemini.js

@@ -1,4 +1,4 @@
-import { BaseAIProvider } from "./base-provider.js";
+import { BaseAIProvider, describeValidationError } from "./base-provider.js";
 import { AISessionManager } from "../session/ai-session-manager.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
@@ -41,6 +41,8 @@ export class GoogleGeminiProvider extends BaseAIProvider {
         });
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         let session = await this.aiSessionManager.getSession(sessionId, "google-gemini");
         if (!session) {
             session = await this.aiSessionManager.createSession({
@@ -152,6 +154,7 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                         iteration: iterations,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `Gemini API error: ${response.status} - ${errorText}`,
                         iterations,
@@ -159,8 +162,14 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                 }
                 const data = (await response.json());
                 const candidate = data.candidates?.[0];
+                stopReason = candidate?.finishReason;
                 if (!candidate || !candidate.content) {
-                    return { success: false, error: "Invalid Gemini API response format", iterations };
+                    return {
+                        stopReason,
+                        success: false,
+                        error: "Invalid Gemini API response format",
+                        iterations,
+                    };
                 }
                 const modelMsg = candidate.content;
                 const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
@@ -197,12 +206,12 @@ export class GoogleGeminiProvider extends BaseAIProvider {
                                 if (!result.valid)
                                     throw new Error(result.errors.join(", "));
                                 await this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: true }));
-                                return { success: true, data: result.data, iterations };
+                                return { stopReason, success: true, data: result.data, iterations };
                             }
                             catch (validationError) {
-                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                const errorMessage = `Validation failed: ${describeValidationError(validationError)}`;
                                 await this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: false, error: errorMessage }));
-                                return { success: false, error: errorMessage, iterations };
+                                return { stopReason, success: false, error: errorMessage, iterations };
                             }
                         }
                     }
@@ -220,9 +229,14 @@ export class GoogleGeminiProvider extends BaseAIProvider {
             }
             catch (error) {
                 clearTimeout(timeout);
-                return { success: false, error: String(error), iterations };
+                return { stopReason, success: false, error: String(error), iterations };
             }
         }
-        return { success: false, error: `Max iterations (${maxIterations}) reached`, iterations };
+        return {
+            stopReason,
+            success: false,
+            error: `Max iterations (${maxIterations}) reached`,
+            iterations,
+        };
     }
 }

package/dist/services/ai/providers/openai-chat-completion.js

@@ -1,4 +1,4 @@
-import { BaseAIProvider, applySafeExtraParams, } from "./base-provider.js";
+import { BaseAIProvider, applySafeExtraParams, describeValidationError, } from "./base-provider.js";
 import { log } from "../../logger.js";
 import { UserProfileValidator } from "../validators/user-profile-validator.js";
 function isErrorResponseBody(data) {
@@ -126,6 +126,8 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
         return result;
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         let session = await this.aiSessionManager.getSession(sessionId, this.sessionProviderTag());
         if (!session) {
             session = await this.aiSessionManager.createSession({
@@ -218,6 +220,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                             'Your model does not support the temperature parameter. Add "memoryTemperature": false to your config file to disable it.';
                     }
                     return {
+                        stopReason,
                         success: false,
                         error: errorMessage,
                         iterations,
@@ -232,6 +235,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                         msg: data.msg,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `API error: ${data.status} - ${data.msg}`,
                         iterations,
@@ -244,19 +248,24 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                     log("Invalid API response format", {
                         provider: this.getProviderName(),
                         model: this.config.model,
-                        response: JSON.stringify(data).slice(0, 1000),
+                        // The body can carry reply text, so log only its shape and size.
+                        responseKeys: typeof data === "object" && data !== null ? Object.keys(data).slice(0, 20) : [],
+                        responseChars: JSON.stringify(data)?.length ?? 0,
                         hasChoices: Array.isArray(choices),
                         choicesLength: Array.isArray(choices) ? choices.length : undefined,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: "Invalid API response format",
                         iterations,
                     };
                 }
                 const choice = data.choices[0];
+                stopReason = choice?.finish_reason ?? undefined;
                 if (!choice) {
                     return {
+                        stopReason,
                         success: false,
                         error: "Invalid API response format",
                         iterations,
@@ -318,27 +327,28 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                                 }
                                 await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: true }));
                                 return {
+                                    stopReason,
                                     success: true,
                                     data: result.data,
                                     iterations,
                                 };
                             }
                             catch (validationError) {
-                                const errorStack = validationError instanceof Error ? validationError.stack : undefined;
                                 log("OpenAI tool response validation failed", {
-                                    error: String(validationError),
-                                    stack: errorStack,
+                                    error: describeValidationError(validationError),
                                     errorType: validationError instanceof Error
                                         ? validationError.constructor.name
                                         : typeof validationError,
                                     toolName: toolSchema.function.name,
                                     iteration: iterations,
-                                    rawArguments: toolCall.function.arguments.slice(0, 500),
+                                    // Log only the size: the arguments are the model's reply.
+                                    argumentsChars: toolCall.function.arguments.length,
                                 });
-                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                const errorMessage = `Validation failed: ${describeValidationError(validationError)}`;
                                 lastErrorMessage = errorMessage;
                                 await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: false, error: errorMessage }));
                                 return {
+                                    stopReason,
                                     success: false,
                                     error: errorMessage,
                                     iterations,
@@ -366,12 +376,14 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
                 clearTimeout(timeout);
                 if (error instanceof Error && error.name === "AbortError") {
                     return {
+                        stopReason,
                         success: false,
                         error: `API request timeout (${iterationTimeout}ms)`,
                         iterations,
                     };
                 }
                 return {
+                    stopReason,
                     success: false,
                     error: String(error),
                     iterations,
@@ -379,6 +391,7 @@ export class OpenAIChatCompletionProvider extends BaseAIProvider {
             }
         }
         return {
+            stopReason,
             success: false,
             error: `Max iterations (${maxIterations}) reached without tool call`,
             iterations,

package/dist/services/ai/providers/openai-responses.js

@@ -15,6 +15,8 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
         return true;
     }
     async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        // Last stop reason the provider reported, so capture diagnostics can see length limits.
+        let stopReason;
         let session = await this.aiSessionManager.getSession(sessionId, "openai-responses");
         if (!session) {
             session = await this.aiSessionManager.createSession({
@@ -67,12 +69,17 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                         iteration: iterations,
                     });
                     return {
+                        stopReason,
                         success: false,
                         error: `API error: ${response.status} - ${errorText}`,
                         iterations,
                     };
                 }
                 const data = (await response.json());
+                stopReason =
+                    data.status === "incomplete"
+                        ? (data.incomplete_details?.reason ?? "incomplete")
+                        : data.status;
                 conversationId = data.conversation || conversationId;
                 if (iterations === 1) {
                     const userSeq = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
@@ -89,6 +96,7 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                         conversationId,
                     });
                     return {
+                        stopReason,
                         success: true,
                         data: this.validateResponse(toolCall),
                         iterations,
@@ -100,12 +108,14 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                 clearTimeout(timeout);
                 if (error instanceof Error && error.name === "AbortError") {
                     return {
+                        stopReason,
                         success: false,
                         error: `API request timeout (${this.config.iterationTimeout}ms)`,
                         iterations,
                     };
                 }
                 return {
+                    stopReason,
                     success: false,
                     error: String(error),
                     iterations,
@@ -113,6 +123,7 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
             }
         }
         return {
+            stopReason,
             success: false,
             error: `Max iterations (${this.config.maxIterations}) reached without tool call`,
             iterations,

package/dist/services/capture-diagnostics.d.ts

@@ -0,0 +1,66 @@
+import type { CaptureAttemptDiagnostics, CaptureAttemptOutcome, CaptureExtractionPath, CaptureFailureReason } from "../core/host.js";
+import type { MemoryHost, MemorySourceType } from "../types/index.js";
+/**
+ * The config fields this module reads. Callers pass `CONFIG`; tests pass a
+ * plain object, so no import of `../config.js` is needed here.
+ */
+export interface CaptureDiagnosticsConfig {
+    captureTrace?: boolean;
+    captureTraceRetentionDays?: number;
+    memoryApiKey?: string;
+    embeddingApiKey?: string;
+    webServerApiToken?: string;
+    webServerAuthPassword?: string;
+}
+export interface CaptureAttemptContext {
+    host: MemoryHost;
+    sourceType: MemorySourceType;
+    sessionId: string;
+}
+/**
+ * The metadata-only record written to the OMMS log for every attempt. Every
+ * key is always present so records from both hosts have one shape; a value a
+ * path could not observe is null.
+ */
+export interface CaptureAttemptRecord {
+    host: MemoryHost;
+    sourceType: MemorySourceType;
+    sessionId: string;
+    path: CaptureExtractionPath | null;
+    provider: string | null;
+    model: string | null;
+    stopReason: string | null;
+    blockTypes: string[] | null;
+    promptChars: number | null;
+    replyChars: number | null;
+    durationMs: number;
+    outcome: CaptureAttemptOutcome;
+    reason: CaptureFailureReason | null;
+}
+export declare const DEFAULT_CAPTURE_TRACE_RETENTION_DAYS = 7;
+export declare function buildCaptureAttemptRecord(context: CaptureAttemptContext, diagnostics: CaptureAttemptDiagnostics, outcome: CaptureAttemptOutcome, durationMs: number): CaptureAttemptRecord;
+/**
+ * Prepare prompt or reply text for the trace file: drop `<private>` regions the
+ * same way memory storage does, then configured secrets, then common key and
+ * token formats.
+ */
+export declare function redactTraceText(text: string, config: CaptureDiagnosticsConfig): string;
+export declare function getTraceDirectory(): string;
+/**
+ * Delete trace files dated more than `captureTraceRetentionDays` before `now`.
+ * The date comes from the file name, not the modification time, and files
+ * that do not match the trace name pattern are never touched.
+ */
+export declare function pruneTraces(config: CaptureDiagnosticsConfig, now?: Date): number;
+/**
+ * Append one trace entry to the day's JSON Lines file. A single append per
+ * entry keeps lines whole when Pi and OpenCode write at the same time.
+ */
+export declare function writeTraceEntry(record: CaptureAttemptRecord, diagnostics: CaptureAttemptDiagnostics, config: CaptureDiagnosticsConfig, now?: Date): void;
+/**
+ * Write the attempt's metadata record to the log and, when tracing is on, its
+ * trace entry. Never throws: diagnostics must not change a capture outcome.
+ */
+export declare function emitCaptureAttempt(record: CaptureAttemptRecord, diagnostics: CaptureAttemptDiagnostics, config: CaptureDiagnosticsConfig, now?: Date): void;
+/** Test hook: forget which day the last trace was written. */
+export declare function resetTraceStateForTests(): void;

package/dist/services/capture-diagnostics.js

@@ -0,0 +1,172 @@
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { getLogDirPath } from "./log-path.js";
+import { log } from "./logger.js";
+import { stripPrivateContent } from "./privacy.js";
+export const DEFAULT_CAPTURE_TRACE_RETENTION_DAYS = 7;
+const TRACE_SCHEMA_VERSION = 1;
+const TRACE_FILE = /^capture-(\d{4})-(\d{2})-(\d{2})\.jsonl$/;
+const REDACTED = "[REDACTED]";
+export function buildCaptureAttemptRecord(context, diagnostics, outcome, durationMs) {
+    const promptChars = diagnostics.systemPrompt === undefined && diagnostics.userPrompt === undefined
+        ? null
+        : (diagnostics.systemPrompt?.length ?? 0) + (diagnostics.userPrompt?.length ?? 0);
+    return {
+        host: context.host,
+        sourceType: context.sourceType,
+        sessionId: context.sessionId,
+        path: diagnostics.path ?? null,
+        provider: diagnostics.provider ?? null,
+        model: diagnostics.model ?? null,
+        stopReason: diagnostics.stopReason ?? null,
+        blockTypes: diagnostics.blockTypes ?? null,
+        promptChars,
+        replyChars: diagnostics.rawReply?.length ?? null,
+        durationMs,
+        outcome,
+        reason: outcome === "failed" ? (diagnostics.failureReason ?? "call-error") : null,
+    };
+}
+// Common key and token formats. Each match is replaced whole, except the
+// Bearer rule, which keeps the scheme so the trace still reads naturally.
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g, REDACTED],
+    [/\bsk-ant-[A-Za-z0-9_-]{10,}/g, REDACTED],
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, REDACTED],
+    [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, REDACTED],
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, REDACTED],
+    [/\bAKIA[0-9A-Z]{16}\b/g, REDACTED],
+    [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, REDACTED],
+    [/\bAIza[0-9A-Za-z_-]{35}/g, REDACTED],
+    [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, REDACTED],
+    [/(\bBearer\s+)[A-Za-z0-9._~+/=-]{16,}/gi, `$1${REDACTED}`],
+];
+function configuredSecrets(config) {
+    return [
+        config.memoryApiKey,
+        config.embeddingApiKey,
+        config.webServerApiToken,
+        config.webServerAuthPassword,
+    ].filter((value) => typeof value === "string" &&
+        // Short values would redact ordinary words; unresolved references are not secrets.
+        value.length >= 8 &&
+        !value.startsWith("env://") &&
+        !value.startsWith("file://"));
+}
+/**
+ * Prepare prompt or reply text for the trace file: drop `<private>` regions the
+ * same way memory storage does, then configured secrets, then common key and
+ * token formats.
+ */
+export function redactTraceText(text, config) {
+    let result = stripPrivateContent(text);
+    for (const secret of configuredSecrets(config)) {
+        result = result.replaceAll(secret, REDACTED);
+    }
+    for (const [pattern, replacement] of SECRET_PATTERNS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}
+function formatDate(d) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+export function getTraceDirectory() {
+    return join(getLogDirPath(), "traces");
+}
+function retentionDays(config) {
+    const days = config.captureTraceRetentionDays;
+    if (typeof days !== "number" || !Number.isFinite(days)) {
+        return DEFAULT_CAPTURE_TRACE_RETENTION_DAYS;
+    }
+    return Math.max(1, Math.floor(days));
+}
+/**
+ * Delete trace files dated more than `captureTraceRetentionDays` before `now`.
+ * The date comes from the file name, not the modification time, and files
+ * that do not match the trace name pattern are never touched.
+ */
+export function pruneTraces(config, now = new Date()) {
+    const dir = getTraceDirectory();
+    let removed = 0;
+    try {
+        if (!existsSync(dir))
+            return 0;
+        const cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        cutoff.setDate(cutoff.getDate() - retentionDays(config));
+        for (const file of readdirSync(dir)) {
+            const match = TRACE_FILE.exec(file);
+            if (!match)
+                continue;
+            const fileDate = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+            if (fileDate < cutoff) {
+                unlinkSync(join(dir, file));
+                removed++;
+            }
+        }
+    }
+    catch (error) {
+        log("Capture trace cleanup failed", { code: errorCode(error) });
+    }
+    return removed;
+}
+let lastTraceDate = null;
+/**
+ * Append one trace entry to the day's JSON Lines file. A single append per
+ * entry keeps lines whole when Pi and OpenCode write at the same time.
+ */
+export function writeTraceEntry(record, diagnostics, config, now = new Date()) {
+    try {
+        const today = formatDate(now);
+        if (lastTraceDate !== today) {
+            lastTraceDate = today;
+            pruneTraces(config, now);
+        }
+        const dir = getTraceDirectory();
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        chmodSync(dir, 0o700);
+        const redact = (value) => value === undefined ? null : redactTraceText(value, config);
+        const entry = {
+            schemaVersion: TRACE_SCHEMA_VERSION,
+            timestamp: now.toISOString(),
+            ...record,
+            systemPrompt: redact(diagnostics.systemPrompt),
+            userPrompt: redact(diagnostics.userPrompt),
+            reply: redact(diagnostics.rawReply),
+        };
+        const file = join(dir, `capture-${today}.jsonl`);
+        appendFileSync(file, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+        // The mode above applies only when the append creates the file; a file
+        // that already existed with wider permissions is narrowed here.
+        chmodSync(file, 0o600);
+    }
+    catch (error) {
+        log("Capture trace write failed", { code: errorCode(error) });
+    }
+}
+/**
+ * Write the attempt's metadata record to the log and, when tracing is on, its
+ * trace entry. Never throws: diagnostics must not change a capture outcome.
+ */
+export function emitCaptureAttempt(record, diagnostics, config, now = new Date()) {
+    try {
+        log("Capture attempt", record);
+    }
+    catch {
+        // The log is best effort here, as everywhere else.
+    }
+    if (config.captureTrace === true) {
+        writeTraceEntry(record, diagnostics, config, now);
+    }
+}
+function errorCode(error) {
+    if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+        return error.code;
+    }
+    return error instanceof Error ? error.name : "unknown";
+}
+/** Test hook: forget which day the last trace was written. */
+export function resetTraceStateForTests() {
+    lastTraceDate = null;
+}

package/dist/services/log-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getLogFilePath(): string;
+export declare function getLogDirPath(): string;

package/dist/services/log-path.js

@@ -0,0 +1,15 @@
+import { homedir } from "os";
+import { join } from "path";
+// Kept apart from logger.ts: many tests replace logger.js with a stub that
+// only has `log`, so modules that need the paths import them from here.
+export function getLogFilePath() {
+    return (process.env.OMMS_LOG_FILE ||
+        // Legacy override, still honoured from the opencode-mem days.
+        process.env.OPENCODE_MEM_LOG_FILE ||
+        join(homedir(), ".omms", "omms.log"));
+}
+export function getLogDirPath() {
+    const logFile = getLogFilePath();
+    const lastSlash = Math.max(logFile.lastIndexOf("/"), logFile.lastIndexOf("\\"));
+    return lastSlash === -1 ? "." : logFile.slice(0, lastSlash);
+}

package/dist/services/logger.js

@@ -1,17 +1,6 @@
 import { appendFileSync, writeFileSync, existsSync, mkdirSync, statSync, renameSync, unlinkSync, readdirSync, } from "fs";
-import { homedir } from "os";
 import { join } from "path";
-function getLogFilePath() {
-    return (process.env.OMMS_LOG_FILE ||
-        // Legacy override, still honoured from the opencode-mem days.
-        process.env.OPENCODE_MEM_LOG_FILE ||
-        join(homedir(), ".omms", "omms.log"));
-}
-function getLogDirPath() {
-    const logFile = getLogFilePath();
-    const lastSlash = Math.max(logFile.lastIndexOf("/"), logFile.lastIndexOf("\\"));
-    return lastSlash === -1 ? "." : logFile.slice(0, lastSlash);
-}
+import { getLogDirPath, getLogFilePath } from "./log-path.js";
 const MAX_LOG_SIZE = 5 * 1024 * 1024;
 const MAX_LOG_DAYS = 30;
 const GLOBAL_LOGGER_KEY = Symbol.for("omms.logger.initialized");

package/dist/v2/legacy-client.js

@@ -222,8 +222,17 @@ export function toLegacyEvent(raw) {
     const envelope = raw?.payload ?? raw;
     const source = envelope?.type === "sync" && envelope.syncEvent ? envelope.syncEvent : envelope;
     const rawType = typeof source?.type === "string" ? source.type.replace(/\.1$/, "") : source?.type;
-    const type = rawType === "session.compaction.ended" ? "session.compacted" : rawType;
     const data = source?.data ?? {};
+    // OpenCode 2.0.14 ends a turn with `session.execution.succeeded` and emits no
+    // `session.idle`; some builds report idleness through `session.status`. The
+    // V1 capture path listens for `session.idle`, so both map onto it.
+    // Subscribed events carry their payload in `data`; bus-style ones in `properties`.
+    const payload = source?.data ?? source?.properties ?? {};
+    if (rawType === "session.execution.succeeded" ||
+        (rawType === "session.status" && payload?.status?.type === "idle")) {
+        return { type: "session.idle", properties: { sessionID: payload.sessionID } };
+    }
+    const type = rawType === "session.compaction.ended" ? "session.compacted" : rawType;
     if (source && typeof source === "object" && "properties" in source) {
         return { type, properties: source.properties };
     }