@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/nodes/index.js

@@ -12,6 +12,7 @@
  * Nodes pair via short codes and communicate through the Gateway WS.
  */
 import { EventEmitter } from 'events';
+import { randomUUID } from 'node:crypto';
 import { logger } from '../utils/logger.js';
 // ============================================================================
 // Platform Capability Maps
@@ -51,6 +52,7 @@ export class NodeManager extends EventEmitter {
     nodes = new Map();
     pendingPairings = new Map();
     config;
+    pendingInvocations = new Map();
     constructor(config) {
         super();
         this.config = {
@@ -58,6 +60,8 @@ export class NodeManager extends EventEmitter {
             pairingTimeoutMs: config?.pairingTimeoutMs ?? 300_000, // 5 minutes
             heartbeatIntervalMs: config?.heartbeatIntervalMs ?? 30_000,
             maxNodes: config?.maxNodes ?? 10,
+            invocationTimeoutMs: config?.invocationTimeoutMs ?? 30_000,
+            maxInvocationTimeoutMs: config?.maxInvocationTimeoutMs ?? 120_000,
         };
     }
     static getInstance(config) {
@@ -67,6 +71,7 @@ export class NodeManager extends EventEmitter {
         return NodeManager.instance;
     }
     static resetInstance() {
+        NodeManager.instance?.shutdown();
         NodeManager.instance = null;
     }
     // --------------------------------------------------------------------------
@@ -141,6 +146,7 @@ export class NodeManager extends EventEmitter {
     removeNode(nodeId) {
         const node = this.nodes.get(nodeId);
         if (node) {
+            this.cancelNodeInvocations(nodeId, 'Node was removed');
             this.nodes.delete(nodeId);
             logger.info(`Node removed: ${node.name} (${nodeId})`);
             this.emit('node:removed', node);
@@ -173,6 +179,7 @@ export class NodeManager extends EventEmitter {
         const node = this.nodes.get(nodeId);
         if (node) {
             node.status = 'offline';
+            this.cancelNodeInvocations(nodeId, `Node ${node.name} went offline`);
             this.emit('node:offline', node);
         }
     }
@@ -195,14 +202,77 @@ export class NodeManager extends EventEmitter {
         }
         const start = Date.now();
         logger.debug(`Node invoke: ${node.name} → ${invocation.capability}`, invocation.params);
-        // In production, this would send a WS message to the node and await response.
-        // For now, return a placeholder indicating the capability was dispatched.
-        this.emit('node:invoke', { node, invocation });
-        return {
-            success: true,
-            data: { dispatched: true, capability: invocation.capability },
-            durationMs: Date.now() - start,
+        if (this.listenerCount('node:invoke') === 0) {
+            return {
+                success: false,
+                error: `No transport is connected for node ${node.name}`,
+                durationMs: Date.now() - start,
+            };
+        }
+        const request = {
+            ...invocation,
+            id: randomUUID(),
+            requestedAt: new Date(start).toISOString(),
         };
+        const requestedTimeout = invocation.timeoutMs ?? this.config.invocationTimeoutMs;
+        const safeRequestedTimeout = Number.isFinite(requestedTimeout) && requestedTimeout > 0
+            ? requestedTimeout
+            : this.config.invocationTimeoutMs;
+        const safeMaximumTimeout = Number.isFinite(this.config.maxInvocationTimeoutMs) &&
+            this.config.maxInvocationTimeoutMs > 0
+            ? this.config.maxInvocationTimeoutMs
+            : 120_000;
+        const timeoutMs = Math.max(1, Math.min(safeMaximumTimeout, safeRequestedTimeout));
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pendingInvocations.delete(request.id);
+                resolve({
+                    success: false,
+                    error: `Node invocation timed out after ${timeoutMs}ms`,
+                    durationMs: Date.now() - start,
+                });
+            }, timeoutMs);
+            timer.unref?.();
+            this.pendingInvocations.set(request.id, {
+                nodeId: node.id,
+                startedAt: start,
+                timer,
+                resolve,
+            });
+            try {
+                this.emit('node:invoke', { node: { ...node }, invocation: request });
+            }
+            catch (error) {
+                const pending = this.pendingInvocations.get(request.id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.pendingInvocations.delete(request.id);
+                resolve({
+                    success: false,
+                    error: `Node transport failed: ${error instanceof Error ? error.message : String(error)}`,
+                    durationMs: Date.now() - start,
+                });
+            }
+        });
+    }
+    /** Complete a correlated invocation. The responding node must match the request owner. */
+    completeInvocation(nodeId, invocationId, result) {
+        const pending = this.pendingInvocations.get(invocationId);
+        if (!pending || pending.nodeId !== nodeId)
+            return false;
+        clearTimeout(pending.timer);
+        this.pendingInvocations.delete(invocationId);
+        pending.resolve({
+            success: result.success,
+            ...(result.data !== undefined ? { data: result.data } : {}),
+            ...(result.error ? { error: result.error } : {}),
+            durationMs: Math.max(0, Date.now() - pending.startedAt),
+        });
+        return true;
+    }
+    getPendingInvocationCount() {
+        return this.pendingInvocations.size;
     }
     // --------------------------------------------------------------------------
     // Convenience Methods
@@ -213,6 +283,42 @@ export class NodeManager extends EventEmitter {
     async getLocation(nodeId) {
         return this.invoke({ nodeId, capability: 'location.get' });
     }
+    async listCalendar(nodeId, params = {}) {
+        const invalidRange = validateCalendarRange(params);
+        if (invalidRange)
+            return { success: false, error: invalidRange };
+        const limit = Math.max(1, Math.min(200, Math.trunc(params.limit ?? 50)));
+        const result = await this.invoke({
+            nodeId,
+            capability: 'calendar.list',
+            params: {
+                ...(params.timeMin ? { timeMin: params.timeMin } : {}),
+                ...(params.timeMax ? { timeMax: params.timeMax } : {}),
+                limit,
+            },
+        });
+        if (!result.success) {
+            return {
+                success: false,
+                ...(result.error ? { error: result.error } : {}),
+                ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+            };
+        }
+        try {
+            return {
+                success: true,
+                data: normalizeCalendarListData(result.data, limit),
+                ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Invalid calendar.list response: ${error instanceof Error ? error.message : String(error)}`,
+                ...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+            };
+        }
+    }
     async sendNotification(nodeId, title, body) {
         return this.invoke({
             nodeId,
@@ -243,6 +349,101 @@ export class NodeManager extends EventEmitter {
         }
         return Array.from(this.pendingPairings.values());
     }
+    shutdown() {
+        for (const nodeId of this.nodes.keys()) {
+            this.cancelNodeInvocations(nodeId, 'Node manager shut down');
+        }
+        this.removeAllListeners();
+    }
+    cancelNodeInvocations(nodeId, error) {
+        for (const [id, pending] of this.pendingInvocations) {
+            if (pending.nodeId !== nodeId)
+                continue;
+            clearTimeout(pending.timer);
+            this.pendingInvocations.delete(id);
+            pending.resolve({
+                success: false,
+                error,
+                durationMs: Math.max(0, Date.now() - pending.startedAt),
+            });
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function isIsoInstant(value) {
+    return /^\d{4}-\d{2}-\d{2}T.+(?:Z|[+-]\d{2}:\d{2})$/u.test(value) &&
+        Number.isFinite(Date.parse(value));
+}
+function isCivilDate(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/u.test(value))
+        return false;
+    const [year, month, day] = value.split('-').map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function validateCalendarRange(params) {
+    if (params.timeMin && !isIsoInstant(params.timeMin))
+        return 'timeMin must be an ISO instant with an explicit offset';
+    if (params.timeMax && !isIsoInstant(params.timeMax))
+        return 'timeMax must be an ISO instant with an explicit offset';
+    if (params.timeMin && params.timeMax && Date.parse(params.timeMax) <= Date.parse(params.timeMin)) {
+        return 'timeMax must be later than timeMin';
+    }
+    if (params.limit !== undefined && (!Number.isFinite(params.limit) || params.limit < 1)) {
+        return 'limit must be a positive number';
+    }
+    return null;
+}
+function normalizeCalendarListData(value, limit) {
+    const root = Array.isArray(value) ? { events: value } : value;
+    if (!isRecord(root) || !Array.isArray(root.events))
+        throw new Error('events must be an array');
+    const timezone = nonEmptyString(root.timezone);
+    if (timezone) {
+        try {
+            new Intl.DateTimeFormat('en-US', { timeZone: timezone });
+        }
+        catch {
+            throw new Error('timezone must be a valid IANA identifier');
+        }
+    }
+    const events = root.events.slice(0, limit).map((raw, index) => {
+        if (!isRecord(raw))
+            throw new Error(`event ${index + 1} must be an object`);
+        const id = nonEmptyString(raw.id);
+        const title = nonEmptyString(raw.title) ?? nonEmptyString(raw.summary);
+        const start = nonEmptyString(raw.start);
+        const end = nonEmptyString(raw.end);
+        const allDay = raw.allDay === true || (start ? isCivilDate(start) : false);
+        if (!id)
+            throw new Error(`event ${index + 1} has no id`);
+        if (!title)
+            throw new Error(`event ${index + 1} has no title`);
+        if (!start || !(allDay ? isCivilDate(start) : isIsoInstant(start))) {
+            throw new Error(`event ${index + 1} has an invalid start`);
+        }
+        if (end && !(allDay ? isCivilDate(end) : isIsoInstant(end))) {
+            throw new Error(`event ${index + 1} has an invalid end`);
+        }
+        if (end && Date.parse(end) < Date.parse(start)) {
+            throw new Error(`event ${index + 1} ends before it starts`);
+        }
+        return {
+            id,
+            title,
+            start,
+            ...(end ? { end } : {}),
+            allDay,
+            ...(nonEmptyString(raw.location) ? { location: nonEmptyString(raw.location) } : {}),
+        };
+    });
+    events.sort((left, right) => Date.parse(left.start) - Date.parse(right.start));
+    return { events, ...(timezone ? { timezone } : {}) };
 }
 // ============================================================================
 // CLI Tool Definitions

package/dist/nodes/transports/adb-transport.d.ts

@@ -4,7 +4,7 @@
  * Executes commands and transfers files to Android devices via ADB.
  * Uses spawn('adb', ...) for all operations.
  */
-import type { DeviceTransport, DeviceCapability, ExecuteResult, ExecuteOptions, TransportConfig } from './base-transport.js';
+import type { DeviceTransport, DeviceCapability, ExecuteResult, ExecuteOptions, TransportConfig, DeviceCalendarEvent } from './base-transport.js';
 export declare class ADBTransport implements DeviceTransport {
     readonly type: "adb";
     private connected;
@@ -40,11 +40,7 @@ export declare class ADBTransport implements DeviceTransport {
     /**
      * Get calendar events for the next N days.
      */
-    getCalendarEvents(days?: number): Promise<{
-        title: string;
-        start: string;
-        end: string;
-    }[]>;
+    getCalendarEvents(days?: number): Promise<DeviceCalendarEvent[] | null>;
     /**
      * List current notifications on the device.
      */

package/dist/nodes/transports/adb-transport.js

@@ -178,27 +178,43 @@ export class ADBTransport {
      * Get calendar events for the next N days.
      */
     async getCalendarEvents(days = 7) {
+        const boundedDays = Number.isFinite(days)
+            ? Math.max(1, Math.min(31, Math.trunc(days)))
+            : 7;
         const now = Date.now();
-        const end = now + days * 24 * 60 * 60 * 1000;
-        const cmd = `content query --uri content://com.android.calendar/events --projection title:dtstart:dtend --where "dtstart>=${now} AND dtend<=${end}" --sort "dtstart ASC"`;
+        const end = now + boundedDays * 24 * 60 * 60 * 1000;
+        const cmd = `content query --uri content://com.android.calendar/instances/when/${now}/${end} ` +
+            '--projection event_id:title:begin:end:eventLocation:allDay --sort "begin ASC"';
         const result = await this.execute(cmd);
         if (result.exitCode !== 0) {
             logger.warn('Failed to get calendar events', { stderr: result.stderr });
-            return [];
+            return null;
         }
         const events = [];
         const lines = result.stdout.split('\n').filter((l) => l.trim());
         for (const line of lines) {
-            const titleMatch = line.match(/title=([^,]+)/);
-            const startMatch = line.match(/dtstart=(\d+)/);
-            const endMatch = line.match(/dtend=(\d+)/);
-            if (titleMatch?.[1] !== undefined) {
-                events.push({
-                    title: titleMatch[1].trim(),
-                    start: startMatch?.[1] !== undefined ? new Date(parseInt(startMatch[1])).toISOString() : '',
-                    end: endMatch?.[1] !== undefined ? new Date(parseInt(endMatch[1])).toISOString() : '',
-                });
-            }
+            if (events.length >= 200)
+                break;
+            const id = line.match(/event_id=(\d+)/)?.[1];
+            const title = line.match(/title=([^,\n]+)/)?.[1]?.trim();
+            const startMs = Number(line.match(/begin=(\d+)/)?.[1]);
+            const endMs = Number(line.match(/(?:^|,\s*)end=(\d+)/)?.[1]);
+            const startDate = new Date(startMs);
+            const endDate = new Date(endMs);
+            if (!id || !title || !Number.isFinite(startMs) || !Number.isFinite(startDate.getTime()))
+                continue;
+            events.push({
+                id,
+                title,
+                start: startDate.toISOString(),
+                ...(Number.isFinite(endMs) && Number.isFinite(endDate.getTime()) && endMs >= startMs
+                    ? { end: endDate.toISOString() }
+                    : {}),
+                allDay: line.match(/allDay=(\d+)/)?.[1] === '1',
+                ...(line.match(/eventLocation=([^,\n]+)/)?.[1]?.trim()
+                    ? { location: line.match(/eventLocation=([^,\n]+)/)[1].trim() }
+                    : {}),
+            });
         }
         return events;
     }

package/dist/nodes/transports/base-transport.d.ts

@@ -21,6 +21,14 @@ export interface ExecuteOptions {
     /** Environment variables */
     env?: Record<string, string>;
 }
+export interface DeviceCalendarEvent {
+    id: string;
+    title: string;
+    start: string;
+    end?: string;
+    allDay: boolean;
+    location?: string;
+}
 export interface TransportConfig {
     /** Device identifier */
     deviceId: string;
@@ -52,4 +60,6 @@ export interface DeviceTransport {
     isConnected(): boolean;
     /** Detect available capabilities on the device */
     getCapabilities(): Promise<DeviceCapability[]>;
+    /** Optional structured calendar reader exposed by capable transports. */
+    getCalendarEvents?(days?: number): Promise<DeviceCalendarEvent[] | null>;
 }

package/dist/observability/run-store.d.ts

@@ -23,6 +23,8 @@ export interface RunMetadata {
     userId?: string;
     /** Session ID */
     sessionId?: string;
+    /** Working directory of the run, used by `buddy run replay` */
+    cwd?: string;
     /** Tags for filtering */
     tags?: string[];
     /**
@@ -170,6 +172,8 @@ export declare class RunStore {
     private artifactIndexDb;
     /** If SQLite/FTS is unavailable, keep run search on the file-scan fallback. */
     private artifactIndexUnavailable;
+    /** Set by dispose(): the artifact index must never be lazily reopened afterwards. */
+    private disposed;
     constructor(runsDir?: string);
     getRunsDir(): string;
     static getInstance(): RunStore;
@@ -205,7 +209,7 @@ export declare class RunStore {
     /**
      * End a run and flush the event stream.
      */
-    endRun(runId: string, status: 'completed' | 'failed' | 'cancelled'): void;
+    endRun(runId: string, status: 'completed' | 'failed' | 'cancelled', finalMetrics?: Partial<RunMetrics>): void;
     /**
      * Save an artifact file for a run. Returns the absolute path.
      */
@@ -281,6 +285,7 @@ export declare class RunStore {
     private scanArtifactIndex;
     private toHealthReport;
     private runDir;
+    private loadDatabaseConstructor;
     private getArtifactIndexDb;
     private indexArtifactForSearch;
     private searchArtifactsWithIndex;

package/dist/observability/run-store.js

@@ -13,9 +13,11 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { randomBytes } from 'crypto';
-import Database from 'better-sqlite3';
+import { isOptionalSqliteUnavailableError, loadBetterSqlite3Sync, SQLITE_INSTALL_GUIDANCE, } from '../database/optional-sqlite.js';
 import { logger } from '../utils/logger.js';
 import { executeHermesLifecycleHook } from '../hooks/hermes-lifecycle-hooks.js';
+import { readJsonAtomicSync, writeJsonAtomicSync } from '../utils/atomic-write.js';
+import { auditLogger } from '../security/audit-logger.js';
 const MAX_RUNS = 30;
 const MAX_ARTIFACT_SEARCH_BYTES = 200_000;
 const ARTIFACT_INDEX_DB = 'artifact-index.sqlite';
@@ -45,6 +47,8 @@ export class RunStore {
     artifactIndexDb = null;
     /** If SQLite/FTS is unavailable, keep run search on the file-scan fallback. */
     artifactIndexUnavailable = false;
+    /** Set by dispose(): the artifact index must never be lazily reopened afterwards. */
+    disposed = false;
     constructor(runsDir) {
         this.runsDir =
             runsDir || process.env.CODEBUDDY_RUNS_DIR || path.join(os.homedir(), '.codebuddy', 'runs');
@@ -74,6 +78,7 @@ export class RunStore {
         return this._currentRunId;
     }
     dispose() {
+        this.disposed = true;
         for (const ws of this.handles.values()) {
             try {
                 ws.destroy();
@@ -145,6 +150,14 @@ export class RunStore {
         });
         this.saveSummary(runId, summary);
         this.pruneOldRuns();
+        // Initialize audit logger in production where RunStore starts
+        try {
+            const auditDir = process.env.CODEBUDDY_AUDIT_DIR || path.join(os.homedir(), '.codebuddy');
+            auditLogger.init({ logDir: auditDir, sessionId: metadata?.sessionId });
+        }
+        catch {
+            // Ignore
+        }
         this._currentRunId = runId;
         setActiveRunStore(this);
         logger.debug(`RunStore: started run ${runId}`, { objective });
@@ -211,13 +224,36 @@ export class RunStore {
         if (summary) {
             summary.eventCount = count;
         }
+        if (event.type === 'tool_call') {
+            const current = this.getRun(runId)?.metrics.toolCallCount ?? 0;
+            this.updateMetrics(runId, { toolCallCount: current + 1 });
+        }
     }
     /**
      * End a run and flush the event stream.
      */
-    endRun(runId, status) {
+    endRun(runId, status, finalMetrics) {
+        if (finalMetrics) {
+            this.updateMetrics(runId, finalMetrics);
+        }
         this.emit(runId, { type: 'run_end', data: { status } });
-        const summary = this.summaries.get(runId);
+        let summary = this.summaries.get(runId);
+        if (!summary) {
+            try {
+                const summaryPath = path.join(this.runDir(runId), 'summary.json');
+                summary = readJsonAtomicSync(summaryPath, null, {
+                    mode: 0o600,
+                    isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value) &&
+                        typeof value.runId === 'string'),
+                }) ?? undefined;
+                if (summary) {
+                    this.summaries.set(runId, summary);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
         if (summary) {
             summary.status = status;
             summary.endedAt = Date.now();
@@ -226,10 +262,27 @@ export class RunStore {
         // Update metrics duration
         try {
             const metricsPath = path.join(this.runDir(runId), 'metrics.json');
-            if (fs.existsSync(metricsPath)) {
-                const metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-                metrics.durationMs = (summary?.endedAt || Date.now()) - (summary?.startedAt || Date.now());
-                fs.writeFileSync(metricsPath, JSON.stringify(metrics, null, 2));
+            const metrics = fs.existsSync(metricsPath)
+                ? readJsonAtomicSync(metricsPath, null, {
+                    mode: 0o600,
+                    isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+                })
+                : null;
+            const durationMs = Math.max(1, (summary?.endedAt || Date.now()) - (summary?.startedAt || Date.now()));
+            if (metrics) {
+                metrics.durationMs = durationMs;
+                writeJsonAtomicSync(metricsPath, metrics, { mode: 0o600 });
+            }
+            else {
+                writeJsonAtomicSync(metricsPath, {
+                    totalTokens: 0,
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalCost: 0,
+                    durationMs,
+                    toolCallCount: 0,
+                    failoverCount: 0,
+                }, { mode: 0o600 });
             }
         }
         catch {
@@ -300,11 +353,12 @@ export class RunStore {
         try {
             const metricsPath = path.join(this.runDir(runId), 'metrics.json');
             let existing = {};
-            if (fs.existsSync(metricsPath)) {
-                existing = JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-            }
+            existing = readJsonAtomicSync(metricsPath, {}, {
+                mode: 0o600,
+                isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+            });
             const merged = { ...existing, ...metrics };
-            fs.writeFileSync(metricsPath, JSON.stringify(merged, null, 2));
+            writeJsonAtomicSync(metricsPath, merged, { mode: 0o600 });
         }
         catch {
             // Ignore
@@ -324,9 +378,10 @@ export class RunStore {
         let metrics = {};
         try {
             const metricsPath = path.join(runDir, 'metrics.json');
-            if (fs.existsSync(metricsPath)) {
-                metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-            }
+            metrics = readJsonAtomicSync(metricsPath, {}, {
+                mode: 0o600,
+                isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+            });
         }
         catch {
             // Ignore
@@ -758,15 +813,22 @@ export class RunStore {
     runDir(runId) {
         return path.join(this.runsDir, runId);
     }
+    loadDatabaseConstructor() {
+        return loadBetterSqlite3Sync();
+    }
     getArtifactIndexDb() {
-        if (this.artifactIndexUnavailable) {
+        // Post-run hooks (learning retrospective, lifecycle hooks) may still call
+        // saveArtifact() after the owner disposed the store; reopening the SQLite
+        // index here would leak the handle the dispose just released.
+        if (this.artifactIndexUnavailable || this.disposed) {
             return null;
         }
         if (this.artifactIndexDb) {
             return this.artifactIndexDb;
         }
         try {
-            const db = new Database(path.join(this.runsDir, ARTIFACT_INDEX_DB));
+            const DatabaseConstructor = this.loadDatabaseConstructor();
+            const db = new DatabaseConstructor(path.join(this.runsDir, ARTIFACT_INDEX_DB));
             db.pragma('journal_mode = WAL');
             // Check if table exists and does NOT have tokenize='trigram'
             let needsRebuild = false;
@@ -826,8 +888,9 @@ export class RunStore {
         }
         catch (err) {
             this.artifactIndexUnavailable = true;
-            logger.debug('RunStore: artifact FTS index unavailable, falling back to file scan', {
-                err: err instanceof Error ? err.message : String(err),
+            const guidance = isOptionalSqliteUnavailableError(err) ? ` ${SQLITE_INSTALL_GUIDANCE}` : '';
+            logger.warn(`RunStore: artifact FTS index unavailable, falling back to file scan.${guidance}`, {
+                error: err instanceof Error ? err.message : String(err),
             });
             return null;
         }
@@ -931,7 +994,7 @@ export class RunStore {
     saveMetrics(runId, metrics) {
         try {
             const metricsPath = path.join(this.runDir(runId), 'metrics.json');
-            fs.writeFileSync(metricsPath, JSON.stringify(metrics, null, 2));
+            writeJsonAtomicSync(metricsPath, metrics, { mode: 0o600 });
         }
         catch {
             // Ignore
@@ -940,7 +1003,7 @@ export class RunStore {
     saveSummary(runId, summary) {
         try {
             const summaryPath = path.join(this.runDir(runId), 'summary.json');
-            fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+            writeJsonAtomicSync(summaryPath, summary, { mode: 0o600 });
         }
         catch {
             // Ignore
@@ -954,8 +1017,12 @@ export class RunStore {
             for (const dir of dirs) {
                 try {
                     const summaryPath = path.join(this.runsDir, dir, 'summary.json');
-                    if (fs.existsSync(summaryPath)) {
-                        const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf-8'));
+                    const summary = readJsonAtomicSync(summaryPath, null, {
+                        mode: 0o600,
+                        isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value) &&
+                            typeof value.runId === 'string'),
+                    });
+                    if (summary) {
                         this.summaries.set(summary.runId, summary);
                         // Count events from file size heuristic (avoid full parse on load)
                         const eventsPath = path.join(this.runsDir, dir, 'events.jsonl');

package/dist/observability/run-trajectory-load.d.ts

@@ -0,0 +1,16 @@
+/**
+ * I/O loader for the unified Trajectory view. Read-only, never-throws.
+ * Missing journals become `sources.missing` — the presenter says « non journalisé ».
+ */
+import { RunStore } from './run-store.js';
+import { type Trajectory, type TrajectorySources } from './run-trajectory.js';
+export interface LoadTrajectoryOptions {
+    since?: number;
+    generatedAt?: string;
+    homeDir?: string;
+    store?: RunStore;
+    timelineEnabled?: boolean;
+}
+export declare function loadTrajectorySources(runId: string, options?: LoadTrajectoryOptions): TrajectorySources;
+export declare function loadTrajectory(runId: string, options?: LoadTrajectoryOptions): Trajectory;
+export declare function parseTrajectorySince(raw: string | undefined): number | undefined;