@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/json-utils.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonSafe<T>(value: string): T | null;

package/dist/json-utils.js

@@ -0,0 +1,8 @@
+export function parseJsonSafe(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/local-openclaw.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFile, stat, writeFile } from "node:fs/promises";
+import { callLlm } from "./http/helpers/llm-client.js";
 const ACTIVE_WINDOW_MS = 30 * 60_000;
 const LOCAL_SNAPSHOT_CACHE_TTL_MS = 1_500;
 let localSnapshotCache = null;
@@ -475,9 +476,9 @@ function groupEventsIntoTurns(events, maxTurns, limits) {
     return turns;
 }
 // ---------------------------------------------------------------------------
-// Rule-based turn summarization (fallback — LLM digest in Phase 1B)
+// Turn summarization — LLM with heuristic fallback
 // ---------------------------------------------------------------------------
-function summarizeTurn(turn, _agentLabel) {
+function heuristicSummarizeTurn(turn, _agentLabel) {
     const normalize = (value) => value.replace(/\s+/g, " ").trim();
     if (turn.errorMessage) {
         return `Error: ${normalize(turn.errorMessage)}`;
@@ -503,6 +504,28 @@ function summarizeTurn(turn, _agentLabel) {
     }
     return "Activity";
 }
+async function summarizeTurnWithLlm(turn, agentLabel) {
+    const parts = [];
+    if (turn.userPrompt)
+        parts.push(`User: ${turn.userPrompt}`);
+    if (turn.toolNames.length > 0)
+        parts.push(`Tools: ${turn.toolNames.join(", ")}`);
+    if (turn.assistantResponse)
+        parts.push(`Assistant: ${turn.assistantResponse}`);
+    if (turn.errorMessage)
+        parts.push(`Error: ${turn.errorMessage}`);
+    const compact = parts.join("\n").slice(0, 4000);
+    const response = await callLlm({
+        taskId: "turn_summary",
+        systemPrompt: "You summarize agent session turns for a dashboard activity feed. " +
+            "Write one clear sentence (max 120 chars) describing what happened. " +
+            "Focus on the action and outcome, not internal details. No markdown.",
+        userPrompt: compact,
+        maxTokens: 64,
+        temperature: 0.15,
+    }, () => heuristicSummarizeTurn(turn, agentLabel));
+    return response.result;
+}
 function isDigestSummaryStale(cached, fresh) {
     if (!cached)
         return true;
@@ -552,9 +575,9 @@ async function writeDigestCache(baseDir, agentId, sessionId, cache) {
 // ---------------------------------------------------------------------------
 // Turn → LiveActivityItem mapping
 // ---------------------------------------------------------------------------
-function turnToActivity(turn, session, cachedSummary, index) {
+async function turnToActivity(turn, session, cachedSummary, index) {
     const agentLabel = session.agentName ?? session.agentId ?? "OpenClaw";
-    const summary = cachedSummary ?? summarizeTurn(turn, agentLabel);
+    const summary = cachedSummary ?? await summarizeTurnWithLlm(turn, agentLabel);
     // Determine activity type
     let type = "delegation";
     if (turn.errorMessage) {
@@ -663,11 +686,11 @@ export async function toLocalLiveActivity(snapshot, limit = 200) {
                 const turn = turns[i];
                 const cached = cachedMap.get(turn.id) ?? null;
                 const agentLabel = session.agentName ?? session.agentId ?? "OpenClaw";
-                const computedSummary = summarizeTurn(turn, agentLabel);
+                const computedSummary = await summarizeTurnWithLlm(turn, agentLabel);
                 const fallbackSummary = isDigestSummaryStale(cached, computedSummary)
                     ? computedSummary
                     : cached;
-                allActivities.push(turnToActivity(turn, session, fallbackSummary, i));
+                allActivities.push(await turnToActivity(turn, session, fallbackSummary, i));
                 // Track for cache
                 if (isDigestSummaryStale(cached, computedSummary)) {
                     newCacheEntries.push({ turnId: turn.id, summary: fallbackSummary });

package/dist/mcp-client-setup.js

@@ -126,7 +126,7 @@ function upsertCodexMcpServerSection(input) {
     const currentText = input.current;
     const lines = currentText.split(/\r?\n/);
     const escapedKey = escapeRegExp(input.key);
-    const headerRegex = new RegExp(`^\\[mcp_servers\\.(?:"${escapedKey}"|${escapedKey})\\]\\s*$`);
+    const headerRegex = new RegExp(`^\\[mcp_servers\\.(?:"${escapedKey}"|'${escapedKey}'|${escapedKey})\\]\\s*$`);
     let headerIndex = -1;
     for (let i = 0; i < lines.length; i += 1) {
         if (headerRegex.test(lines[i].trim())) {
@@ -193,12 +193,12 @@ function removeCodexLegacyScopedMcpSections(input) {
     let index = 0;
     while (index < lines.length) {
         const trimmed = lines[index].trim();
-        const headerMatch = trimmed.match(/^\[mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_]+))\]\s*$/);
+        const headerMatch = trimmed.match(/^\[mcp_servers\.(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_]+))\]\s*$/);
         if (!headerMatch) {
             index += 1;
             continue;
         }
-        const key = (headerMatch[1] ?? headerMatch[2] ?? "").trim();
+        const key = (headerMatch[1] ?? headerMatch[2] ?? headerMatch[3] ?? "").trim();
         const isLegacyScoped = key !== input.baseKey &&
             key.startsWith(scopedPrefix);
         if (!isLegacyScoped) {

package/dist/mcp-http-handler.js

@@ -5,73 +5,47 @@ const DEFAULT_PROTOCOL_VERSION = "2024-11-05";
 //
 // NOTE: This scopes only the tools exposed by this plugin (OrgX reporting + mutation).
 // It cannot restrict OpenClaw-native tools (filesystem, shell, etc).
+// Base tools available to all domain scopes
+const ORGX_BASE_TOOLS = [
+    "orgx_status",
+    "orgx_sync",
+    "list_agent_configs",
+    "get_agent_config",
+    "orgx_emit_activity",
+    "orgx_report_progress",
+    "update_stream_progress",
+    "orgx_register_artifact",
+    "orgx_request_decision",
+    "orgx_spawn_check",
+    // Proof ladder tools (all domains)
+    "orgx_quality_score",
+    "orgx_proof_status",
+    "orgx_record_outcome",
+    "orgx_get_outcome_attribution",
+    "orgx_verify_completion",
+];
 const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
-    engineering: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    product: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    design: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    marketing: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    sales: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
+    engineering: [...ORGX_BASE_TOOLS],
+    product: [...ORGX_BASE_TOOLS],
+    design: [...ORGX_BASE_TOOLS],
+    marketing: [...ORGX_BASE_TOOLS],
+    sales: [...ORGX_BASE_TOOLS],
     operations: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
+        ...ORGX_BASE_TOOLS,
+        "update_agent_config",
         // Operations is allowed to do explicit changesets for remediation/runbooks.
         "orgx_apply_changeset",
+        // Stream reassignment is a targeted operational mutation.
+        "orgx_reassign_stream",
+        "orgx_reassign_streams",
     ],
     orchestration: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
+        ...ORGX_BASE_TOOLS,
+        "update_agent_config",
         // Orchestrator is the primary mutation surface by design.
         "orgx_apply_changeset",
+        "orgx_reassign_stream",
+        "orgx_reassign_streams",
     ],
 };
 function isRecord(value) {

package/dist/next-up-queue-store.d.ts

@@ -6,10 +6,17 @@ export type NextUpPinnedEntry = {
     createdAt: string;
     updatedAt: string;
 };
+export type NextUpSuppressedEntry = {
+    initiativeId: string;
+    workstreamId: string;
+    createdAt: string;
+    updatedAt: string;
+};
 type PersistedNextUpQueue = {
-    version: 1;
+    version: 1 | 2;
     updatedAt: string;
     pins: NextUpPinnedEntry[];
+    suppressions: NextUpSuppressedEntry[];
 };
 export declare function readNextUpQueuePins(): PersistedNextUpQueue;
 export declare function upsertNextUpQueuePin(input: {
@@ -28,4 +35,12 @@ export declare function setNextUpQueuePinOrder(input: {
         workstreamId: string;
     }>;
 }): PersistedNextUpQueue;
+export declare function suppressNextUpQueueItem(input: {
+    initiativeId: string;
+    workstreamId: string;
+}): PersistedNextUpQueue;
+export declare function unsuppressNextUpQueueItem(input: {
+    initiativeId: string;
+    workstreamId: string;
+}): PersistedNextUpQueue;
 export {};

package/dist/next-up-queue-store.js

@@ -1,7 +1,9 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { existsSync, readFileSync, } from "node:fs";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
 import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
 const MAX_PINS = 240;
+const MAX_SUPPRESSIONS = 2_000;
 function storeDir() {
     return getOrgxPluginConfigDir();
 }
@@ -9,22 +11,7 @@ function storeFile() {
     return getOrgxPluginConfigPath("next-up-queue.json");
 }
 function ensureStoreDir() {
-    const dir = storeDir();
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        // best effort
-    }
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
+    ensureStoreDirSync(storeDir());
 }
 function normalizeNullableString(value) {
     if (typeof value !== "string")
@@ -42,31 +29,56 @@ function normalizeEntry(input) {
         updatedAt: input.updatedAt,
     };
 }
+function normalizeSuppression(input) {
+    return {
+        initiativeId: input.initiativeId.trim(),
+        workstreamId: input.workstreamId.trim(),
+        createdAt: input.createdAt,
+        updatedAt: input.updatedAt,
+    };
+}
+function entryKey(input) {
+    return `${input.initiativeId}:${input.workstreamId}`;
+}
+function createEmptyStore() {
+    return {
+        version: 2,
+        updatedAt: new Date().toISOString(),
+        pins: [],
+        suppressions: [],
+    };
+}
 export function readNextUpQueuePins() {
     const file = storeFile();
     try {
         if (!existsSync(file)) {
-            return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+            return createEmptyStore();
         }
         const raw = readFileSync(file, "utf8");
-        const parsed = parseJson(raw);
+        const parsed = parseJsonSafe(raw);
         if (!parsed || typeof parsed !== "object") {
             backupCorruptFileSync(file);
-            return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+            return createEmptyStore();
         }
         const pins = Array.isArray(parsed.pins) ? parsed.pins : [];
+        const suppressions = Array.isArray(parsed.suppressions)
+            ? parsed.suppressions
+            : [];
         return {
-            version: 1,
+            version: 2,
             updatedAt: typeof parsed.updatedAt === "string"
                 ? parsed.updatedAt
                 : new Date().toISOString(),
             pins: pins
                 .filter((entry) => Boolean(entry && typeof entry === "object"))
                 .map((entry) => normalizeEntry(entry)),
+            suppressions: suppressions
+                .filter((entry) => Boolean(entry && typeof entry === "object"))
+                .map((entry) => normalizeSuppression(entry)),
         };
     }
     catch {
-        return { version: 1, updatedAt: new Date().toISOString(), pins: [] };
+        return createEmptyStore();
     }
 }
 export function upsertNextUpQueuePin(input) {
@@ -79,7 +91,7 @@ export function upsertNextUpQueuePin(input) {
     const now = new Date().toISOString();
     const next = readNextUpQueuePins();
     const key = `${initiativeId}:${workstreamId}`;
-    const existing = next.pins.find((pin) => `${pin.initiativeId}:${pin.workstreamId}` === key);
+    const existing = next.pins.find((pin) => entryKey(pin) === key);
     const updated = normalizeEntry({
         initiativeId,
         workstreamId,
@@ -88,7 +100,8 @@ export function upsertNextUpQueuePin(input) {
         createdAt: existing?.createdAt ?? now,
         updatedAt: now,
     });
-    next.pins = [updated, ...next.pins.filter((pin) => `${pin.initiativeId}:${pin.workstreamId}` !== key)].slice(0, MAX_PINS);
+    next.pins = [updated, ...next.pins.filter((pin) => entryKey(pin) !== key)].slice(0, MAX_PINS);
+    next.suppressions = next.suppressions.filter((suppression) => entryKey(suppression) !== key);
     next.updatedAt = now;
     try {
         writeJsonFileAtomicSync(storeFile(), next, 0o600);
@@ -107,7 +120,7 @@ export function removeNextUpQueuePin(input) {
     ensureStoreDir();
     const next = readNextUpQueuePins();
     const key = `${initiativeId}:${workstreamId}`;
-    const filtered = next.pins.filter((pin) => `${pin.initiativeId}:${pin.workstreamId}` !== key);
+    const filtered = next.pins.filter((pin) => entryKey(pin) !== key);
     if (filtered.length === next.pins.length)
         return next;
     next.pins = filtered;
@@ -158,6 +171,39 @@ export function setNextUpQueuePinOrder(input) {
         ordered.push(pin);
     }
     next.pins = ordered.slice(0, MAX_PINS);
+    if (seen.size > 0 && next.suppressions.length > 0) {
+        next.suppressions = next.suppressions.filter((suppression) => !seen.has(entryKey(suppression)));
+    }
+    next.updatedAt = now;
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}
+export function suppressNextUpQueueItem(input) {
+    const initiativeId = input.initiativeId.trim();
+    const workstreamId = input.workstreamId.trim();
+    if (!initiativeId || !workstreamId) {
+        return readNextUpQueuePins();
+    }
+    ensureStoreDir();
+    const now = new Date().toISOString();
+    const next = readNextUpQueuePins();
+    const key = `${initiativeId}:${workstreamId}`;
+    const existing = next.suppressions.find((suppression) => entryKey(suppression) === key);
+    next.suppressions = [
+        normalizeSuppression({
+            initiativeId,
+            workstreamId,
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        }),
+        ...next.suppressions.filter((suppression) => entryKey(suppression) !== key),
+    ].slice(0, MAX_SUPPRESSIONS);
+    next.pins = next.pins.filter((pin) => entryKey(pin) !== key);
     next.updatedAt = now;
     try {
         writeJsonFileAtomicSync(storeFile(), next, 0o600);
@@ -167,3 +213,25 @@ export function setNextUpQueuePinOrder(input) {
     }
     return next;
 }
+export function unsuppressNextUpQueueItem(input) {
+    const initiativeId = input.initiativeId.trim();
+    const workstreamId = input.workstreamId.trim();
+    if (!initiativeId || !workstreamId) {
+        return readNextUpQueuePins();
+    }
+    ensureStoreDir();
+    const next = readNextUpQueuePins();
+    const key = `${initiativeId}:${workstreamId}`;
+    const filtered = next.suppressions.filter((suppression) => entryKey(suppression) !== key);
+    if (filtered.length === next.suppressions.length)
+        return next;
+    next.suppressions = filtered;
+    next.updatedAt = new Date().toISOString();
+    try {
+        writeJsonFileAtomicSync(storeFile(), next, 0o600);
+    }
+    catch {
+        // best effort
+    }
+    return next;
+}

package/dist/outbox.d.ts

@@ -11,6 +11,10 @@ export interface OutboxEvent {
     payload: Record<string, unknown>;
     /** Converted to a LiveActivityItem for dashboard display. */
     activityItem: LiveActivityItem;
+    /** Internal replay diagnostics for bounded retry/dead-letter handling. */
+    replayFailures?: number;
+    lastReplayError?: string | null;
+    lastReplayAt?: string | null;
 }
 export interface OutboxSummary {
     pendingTotal: number;
@@ -18,6 +22,7 @@ export interface OutboxSummary {
     oldestEventAt: string | null;
     newestEventAt: string | null;
 }
+export declare function appendOutboxDeadLetter(sessionId: string, event: OutboxEvent, reason: string, error?: string | null): Promise<void>;
 export declare function readOutbox(sessionId: string): Promise<OutboxEvent[]>;
 export declare function appendToOutbox(sessionId: string, event: OutboxEvent): Promise<void>;
 export declare function replaceOutbox(sessionId: string, events: OutboxEvent[]): Promise<void>;

package/dist/outbox.js

@@ -4,8 +4,9 @@
  * Events are flushed on next successful sync.
  */
 import { join } from "node:path";
-import { readFile, writeFile, mkdir, chmod, rename, unlink, readdir, } from "node:fs/promises";
+import { readFile, writeFile, mkdir, chmod, rename, unlink, readdir, appendFile, } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
+import { classifyOutboxReplaySkip } from "./event-sanitization.js";
 import { getOrgxOutboxDir } from "./paths.js";
 function outboxDir() {
     return getOrgxOutboxDir();
@@ -36,6 +37,11 @@ async function hardenPath(path, mode) {
         // best effort
     }
 }
+/** Events older than 7 days are stale — sync will never recover them. */
+const OUTBOX_EVENT_TTL_MS = 7 * 24 * 60 * 60_000;
+/** Hard cap per session to prevent unbounded growth if sync repeatedly fails. */
+const OUTBOX_MAX_EVENTS_PER_SESSION = 500;
+const DEAD_LETTER_DIRNAME = "_dead-letter";
 async function ensureDir() {
     const dir = outboxDir();
     try {
@@ -46,6 +52,12 @@ async function ensureDir() {
         // Directory may already exist
     }
 }
+function deadLetterDir() {
+    return join(outboxDir(), DEAD_LETTER_DIRNAME);
+}
+function deadLetterPath(sessionId) {
+    return join(deadLetterDir(), `${normalizeSessionId(sessionId)}.jsonl`);
+}
 function outboxPath(sessionId) {
     return join(outboxDir(), `${normalizeSessionId(sessionId)}.json`);
 }
@@ -89,13 +101,79 @@ async function writeFileAtomic(targetPath, content, mode) {
     }
     await hardenPath(targetPath, mode);
 }
+async function appendOutboxDeadLetterRecord(sessionId, record) {
+    await ensureDir();
+    const dir = deadLetterDir();
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await hardenPath(dir, 0o700);
+    const targetPath = deadLetterPath(sessionId);
+    await appendFile(targetPath, `${JSON.stringify(record)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await hardenPath(targetPath, 0o600);
+}
+export async function appendOutboxDeadLetter(sessionId, event, reason, error) {
+    const droppedAt = new Date().toISOString();
+    await appendOutboxDeadLetterRecord(sessionId, {
+        droppedAt,
+        queueId: normalizeSessionId(sessionId),
+        reason,
+        error: error ?? null,
+        event,
+    });
+}
+/** Drop stale events and enforce per-session cap. Returns true if any were removed. */
+function pruneOutboxEvents(events) {
+    const cutoff = Date.now() - OUTBOX_EVENT_TTL_MS;
+    const fresh = events.filter((e) => {
+        const epoch = Date.parse(e.timestamp);
+        return Number.isFinite(epoch) && epoch >= cutoff;
+    });
+    // Keep newest events if over cap.
+    const capped = fresh.length > OUTBOX_MAX_EVENTS_PER_SESSION
+        ? fresh.slice(fresh.length - OUTBOX_MAX_EVENTS_PER_SESSION)
+        : fresh;
+    return { pruned: capped, changed: capped.length !== events.length };
+}
 export async function readOutbox(sessionId) {
-    const targetPath = outboxPath(sessionId);
+    let targetPath;
+    try {
+        targetPath = outboxPath(sessionId);
+    }
+    catch {
+        return [];
+    }
     try {
         const raw = await readFile(targetPath, "utf8");
         try {
             const parsed = JSON.parse(raw);
-            return Array.isArray(parsed) ? parsed : [];
+            const events = Array.isArray(parsed) ? parsed : [];
+            const { pruned, changed } = pruneOutboxEvents(events);
+            const filtered = [];
+            let filteredChanged = changed;
+            for (const event of pruned) {
+                const skipReason = classifyOutboxReplaySkip(event);
+                if (!skipReason) {
+                    filtered.push(event);
+                    continue;
+                }
+                filteredChanged = true;
+                await appendOutboxDeadLetter(sessionId, event, `pruned_on_read:${skipReason}`, null);
+            }
+            // Write back if stale events were dropped.
+            if (filteredChanged) {
+                if (filtered.length === 0) {
+                    try {
+                        await unlink(targetPath);
+                    }
+                    catch { /* ok */ }
+                }
+                else {
+                    await writeFileAtomic(targetPath, JSON.stringify(filtered), 0o600);
+                }
+            }
+            return filtered;
         }
         catch {
             await backupCorruptOutboxFile(targetPath);
@@ -107,9 +185,21 @@ export async function readOutbox(sessionId) {
     }
 }
 export async function appendToOutbox(sessionId, event) {
+    let normalizedSessionId;
+    try {
+        normalizedSessionId = normalizeSessionId(sessionId);
+    }
+    catch {
+        return;
+    }
+    const skipReason = classifyOutboxReplaySkip(event);
+    if (skipReason) {
+        await appendOutboxDeadLetter(normalizedSessionId, event, `suppressed_on_append:${skipReason}`, null);
+        return;
+    }
     await ensureDir();
-    const targetPath = outboxPath(sessionId);
-    const existing = await readOutbox(sessionId);
+    const targetPath = outboxPath(normalizedSessionId);
+    const existing = await readOutbox(normalizedSessionId);
     const idx = existing.findIndex((item) => item.id === event.id);
     if (idx >= 0) {
         existing[idx] = event;
@@ -117,11 +207,18 @@ export async function appendToOutbox(sessionId, event) {
     else {
         existing.push(event);
     }
-    await writeFileAtomic(targetPath, JSON.stringify(existing, null, 2), 0o600);
+    await writeFileAtomic(targetPath, JSON.stringify(existing), 0o600);
 }
 export async function replaceOutbox(sessionId, events) {
+    let normalizedSessionId;
+    try {
+        normalizedSessionId = normalizeSessionId(sessionId);
+    }
+    catch {
+        return;
+    }
     await ensureDir();
-    const targetPath = outboxPath(sessionId);
+    const targetPath = outboxPath(normalizedSessionId);
     if (events.length === 0) {
         try {
             await unlink(targetPath);
@@ -132,7 +229,7 @@ export async function replaceOutbox(sessionId, events) {
             return;
         }
     }
-    await writeFileAtomic(targetPath, JSON.stringify(events, null, 2), 0o600);
+    await writeFileAtomic(targetPath, JSON.stringify(events), 0o600);
 }
 export async function readAllOutboxItems() {
     try {
@@ -209,8 +306,15 @@ export async function readOutboxSummary() {
     }
 }
 export async function clearOutbox(sessionId) {
+    let normalizedSessionId;
+    try {
+        normalizedSessionId = normalizeSessionId(sessionId);
+    }
+    catch {
+        return;
+    }
     try {
-        await unlink(outboxPath(sessionId));
+        await unlink(outboxPath(normalizedSessionId));
     }
     catch {
         // File may not exist