clawvault 1.4.2 → 1.5.1

package/bin/clawvault.js

@@ -1081,5 +1081,53 @@ program
     }
   });
 
+// === REPAIR-SESSION ===
+program
+  .command('repair-session')
+  .description('Repair corrupted OpenClaw session transcripts')
+  .option('-s, --session <id>', 'Session ID (defaults to current main session)')
+  .option('-a, --agent <id>', 'Agent ID (defaults to configured agent)')
+  .option('--backup', 'Create backup before repair (default: true)', true)
+  .option('--no-backup', 'Skip backup creation')
+  .option('--dry-run', 'Show what would be repaired without writing')
+  .option('--list', 'List available sessions')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const {
+        repairSessionCommand,
+        formatRepairResult,
+        listAgentSessions
+      } = await import('../dist/commands/repair-session.js');
+      
+      // List mode
+      if (options.list) {
+        console.log(listAgentSessions(options.agent));
+        return;
+      }
+      
+      const result = await repairSessionCommand({
+        sessionId: options.session,
+        agentId: options.agent,
+        backup: options.backup,
+        dryRun: options.dryRun
+      });
+      
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(formatRepairResult(result, { dryRun: options.dryRun }));
+      }
+      
+      // Exit with code 1 if corruption was found but not fixed (dry-run)
+      if (result.corruptedEntries.length > 0 && !result.repaired) {
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error(chalk.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
 // Parse and run
 program.parse();

package/dist/chunk-AZRV2I5U.js

@@ -0,0 +1,133 @@
+// src/lib/session-utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function getOpenClawAgentsDir() {
+  return path.join(os.homedir(), ".openclaw", "agents");
+}
+function getSessionsDir(agentId) {
+  return path.join(getOpenClawAgentsDir(), agentId, "sessions");
+}
+function getSessionsJsonPath(agentId) {
+  return path.join(getSessionsDir(agentId), "sessions.json");
+}
+function getSessionFilePath(agentId, sessionId) {
+  return path.join(getSessionsDir(agentId), `${sessionId}.jsonl`);
+}
+function listAgents() {
+  const agentsDir = getOpenClawAgentsDir();
+  if (!fs.existsSync(agentsDir)) {
+    return [];
+  }
+  return fs.readdirSync(agentsDir).filter((name) => {
+    const sessionsDir = getSessionsDir(name);
+    return fs.existsSync(sessionsDir) && fs.statSync(sessionsDir).isDirectory();
+  });
+}
+function loadSessionsStore(agentId) {
+  const sessionsJsonPath = getSessionsJsonPath(agentId);
+  if (!fs.existsSync(sessionsJsonPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(sessionsJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function findMainSession(agentId) {
+  const store = loadSessionsStore(agentId);
+  if (!store) return null;
+  const mainKey = `agent:${agentId}:main`;
+  const entry = store[mainKey];
+  if (entry?.sessionId) {
+    const filePath = getSessionFilePath(agentId, entry.sessionId);
+    if (fs.existsSync(filePath)) {
+      return {
+        sessionId: entry.sessionId,
+        sessionKey: mainKey,
+        agentId,
+        filePath,
+        updatedAt: entry.updatedAt
+      };
+    }
+  }
+  return null;
+}
+function findSessionById(agentId, sessionId) {
+  const filePath = getSessionFilePath(agentId, sessionId);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const store = loadSessionsStore(agentId);
+  let sessionKey;
+  let updatedAt;
+  if (store) {
+    for (const [key, entry] of Object.entries(store)) {
+      if (entry.sessionId === sessionId) {
+        sessionKey = key;
+        updatedAt = entry.updatedAt;
+        break;
+      }
+    }
+  }
+  return {
+    sessionId,
+    sessionKey: sessionKey || `agent:${agentId}:unknown`,
+    agentId,
+    filePath,
+    updatedAt
+  };
+}
+function listSessions(agentId) {
+  const sessionsDir = getSessionsDir(agentId);
+  if (!fs.existsSync(sessionsDir)) {
+    return [];
+  }
+  const store = loadSessionsStore(agentId);
+  const sessions = [];
+  const files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".backup") && !f.includes(".deleted") && !f.includes(".corrupted"));
+  for (const file of files) {
+    const sessionId = file.replace(".jsonl", "");
+    const filePath = path.join(sessionsDir, file);
+    let sessionKey = `agent:${agentId}:unknown`;
+    let updatedAt;
+    if (store) {
+      for (const [key, entry] of Object.entries(store)) {
+        if (entry.sessionId === sessionId) {
+          sessionKey = key;
+          updatedAt = entry.updatedAt;
+          break;
+        }
+      }
+    }
+    sessions.push({
+      sessionId,
+      sessionKey,
+      agentId,
+      filePath,
+      updatedAt
+    });
+  }
+  return sessions.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+function backupSession(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "-").slice(0, 15);
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+export {
+  getOpenClawAgentsDir,
+  getSessionsDir,
+  getSessionsJsonPath,
+  getSessionFilePath,
+  listAgents,
+  loadSessionsStore,
+  findMainSession,
+  findSessionById,
+  listSessions,
+  backupSession
+};

package/dist/chunk-L53L5FCL.js

@@ -0,0 +1,200 @@
+// src/lib/session-repair.ts
+import * as fs from "fs";
+function parseTranscript(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim());
+  const entries = [];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    try {
+      const entry = JSON.parse(raw);
+      entries.push({ line: i + 1, entry, raw });
+    } catch {
+      console.warn(`Warning: Could not parse line ${i + 1}`);
+    }
+  }
+  return entries;
+}
+function extractToolUses(entries) {
+  const toolUses = /* @__PURE__ */ new Map();
+  for (const { line, entry } of entries) {
+    if (entry.type !== "message") continue;
+    if (entry.message?.role !== "assistant") continue;
+    const isAborted = entry.message.stopReason === "aborted";
+    const content = entry.message.content || [];
+    for (const block of content) {
+      if (block.type === "toolCall" || block.type === "tool_use" || block.type === "functionCall") {
+        if (block.id) {
+          const isPartial = !!block.partialJson;
+          toolUses.set(block.id, {
+            id: block.id,
+            lineNumber: line,
+            entryId: entry.id,
+            isAborted: isAborted || isPartial,
+            isPartial,
+            name: block.name
+          });
+        }
+      }
+    }
+  }
+  return toolUses;
+}
+function findCorruptedEntries(entries, toolUses) {
+  const corrupted = [];
+  const entriesToRemove = /* @__PURE__ */ new Set();
+  for (const [toolId, info] of toolUses) {
+    if (info.isAborted) {
+      corrupted.push({
+        lineNumber: info.lineNumber,
+        entryId: info.entryId,
+        type: "aborted_tool_use",
+        toolUseId: toolId,
+        description: `Aborted tool_use${info.name ? ` (${info.name})` : ""} with id: ${toolId}`
+      });
+      entriesToRemove.add(info.entryId);
+    }
+  }
+  for (const { line, entry } of entries) {
+    if (entry.type !== "message") continue;
+    if (entry.message?.role !== "toolResult") continue;
+    const content = entry.message.content || [];
+    let toolCallId;
+    const msg = entry.message;
+    toolCallId = msg.toolCallId || msg.toolUseId;
+    if (!toolCallId) {
+      for (const block of content) {
+        if (block.toolCallId || block.toolUseId) {
+          toolCallId = block.toolCallId || block.toolUseId;
+          break;
+        }
+      }
+    }
+    if (!toolCallId) continue;
+    const toolUse = toolUses.get(toolCallId);
+    if (!toolUse || toolUse.isAborted) {
+      corrupted.push({
+        lineNumber: line,
+        entryId: entry.id,
+        type: "orphaned_tool_result",
+        toolUseId: toolCallId,
+        description: toolUse ? `Orphaned tool_result references aborted tool_use: ${toolCallId}` : `Orphaned tool_result references non-existent tool_use: ${toolCallId}`
+      });
+      entriesToRemove.add(entry.id);
+    }
+  }
+  return { corrupted, entriesToRemove };
+}
+function computeParentRelinks(entries, entriesToRemove) {
+  const relinks = [];
+  const entryParents = /* @__PURE__ */ new Map();
+  for (const { entry } of entries) {
+    entryParents.set(entry.id, entry.parentId);
+  }
+  for (const { line, entry } of entries) {
+    if (entriesToRemove.has(entry.id)) continue;
+    if (!entry.parentId) continue;
+    if (!entriesToRemove.has(entry.parentId)) continue;
+    let newParentId = entry.parentId;
+    while (newParentId && entriesToRemove.has(newParentId)) {
+      newParentId = entryParents.get(newParentId) || null;
+    }
+    if (newParentId !== entry.parentId) {
+      relinks.push({
+        lineNumber: line,
+        entryId: entry.id,
+        oldParentId: entry.parentId,
+        newParentId: newParentId || "null"
+      });
+    }
+  }
+  return relinks;
+}
+function analyzeSession(filePath) {
+  const entries = parseTranscript(filePath);
+  const sessionEntry = entries.find((e) => e.entry.type === "session");
+  const sessionId = sessionEntry?.entry.id || "unknown";
+  const toolUses = extractToolUses(entries);
+  const { corrupted, entriesToRemove } = findCorruptedEntries(entries, toolUses);
+  const parentRelinks = computeParentRelinks(entries, entriesToRemove);
+  return {
+    sessionId,
+    totalLines: entries.length,
+    corruptedEntries: corrupted,
+    parentRelinks,
+    removedCount: entriesToRemove.size,
+    relinkedCount: parentRelinks.length,
+    repaired: false
+  };
+}
+function repairSession(filePath, options = {}) {
+  const { backup = true, dryRun = false } = options;
+  const entries = parseTranscript(filePath);
+  const sessionEntry = entries.find((e) => e.entry.type === "session");
+  const sessionId = sessionEntry?.entry.id || "unknown";
+  const toolUses = extractToolUses(entries);
+  const { corrupted, entriesToRemove } = findCorruptedEntries(entries, toolUses);
+  const parentRelinks = computeParentRelinks(entries, entriesToRemove);
+  if (corrupted.length === 0) {
+    return {
+      sessionId,
+      totalLines: entries.length,
+      corruptedEntries: [],
+      parentRelinks: [],
+      removedCount: 0,
+      relinkedCount: 0,
+      repaired: false
+    };
+  }
+  if (dryRun) {
+    return {
+      sessionId,
+      totalLines: entries.length,
+      corruptedEntries: corrupted,
+      parentRelinks,
+      removedCount: entriesToRemove.size,
+      relinkedCount: parentRelinks.length,
+      repaired: false
+    };
+  }
+  let backupPath;
+  if (backup) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "-").slice(0, 15);
+    backupPath = `${filePath}.backup-${timestamp}`;
+    fs.copyFileSync(filePath, backupPath);
+  }
+  const relinkMap = /* @__PURE__ */ new Map();
+  for (const relink of parentRelinks) {
+    relinkMap.set(relink.entryId, relink.newParentId === "null" ? null : relink.newParentId);
+  }
+  const repairedLines = [];
+  for (const { entry, raw } of entries) {
+    if (entriesToRemove.has(entry.id)) continue;
+    if (relinkMap.has(entry.id)) {
+      const newEntry = { ...entry, parentId: relinkMap.get(entry.id) };
+      repairedLines.push(JSON.stringify(newEntry));
+    } else {
+      repairedLines.push(raw);
+    }
+  }
+  fs.writeFileSync(filePath, repairedLines.join("\n") + "\n");
+  return {
+    sessionId,
+    totalLines: entries.length,
+    corruptedEntries: corrupted,
+    parentRelinks,
+    removedCount: entriesToRemove.size,
+    relinkedCount: parentRelinks.length,
+    backupPath,
+    repaired: true
+  };
+}
+
+export {
+  parseTranscript,
+  extractToolUses,
+  findCorruptedEntries,
+  computeParentRelinks,
+  analyzeSession,
+  repairSession
+};

package/dist/commands/repair-session.d.ts

@@ -0,0 +1,38 @@
+import { SessionInfo } from '../lib/session-utils.js';
+import { RepairResult } from '../lib/session-repair.js';
+
+/**
+ * repair-session command - Repair corrupted OpenClaw session transcripts
+ *
+ * Fixes issues like:
+ * - Aborted tool calls with partial JSON
+ * - Orphaned tool_result messages referencing non-existent tool_use IDs
+ * - Broken parent chain references
+ */
+
+interface RepairSessionOptions {
+    sessionId?: string;
+    agentId?: string;
+    backup?: boolean;
+    dryRun?: boolean;
+}
+/**
+ * Resolve the session to repair
+ */
+declare function resolveSession(options: RepairSessionOptions): SessionInfo | null;
+/**
+ * Format repair result for CLI output
+ */
+declare function formatRepairResult(result: RepairResult, options?: {
+    dryRun?: boolean;
+}): string;
+/**
+ * Main repair-session command handler
+ */
+declare function repairSessionCommand(options: RepairSessionOptions): Promise<RepairResult>;
+/**
+ * List available sessions for an agent (for --list flag)
+ */
+declare function listAgentSessions(agentId?: string): string;
+
+export { type RepairSessionOptions, formatRepairResult, listAgentSessions, repairSessionCommand, resolveSession };

package/dist/commands/repair-session.js

@@ -0,0 +1,121 @@
+import {
+  analyzeSession,
+  repairSession
+} from "../chunk-L53L5FCL.js";
+import {
+  findMainSession,
+  findSessionById,
+  listAgents
+} from "../chunk-AZRV2I5U.js";
+
+// src/commands/repair-session.ts
+import * as fs from "fs";
+function resolveSession(options) {
+  const { sessionId, agentId } = options;
+  if (sessionId && agentId) {
+    return findSessionById(agentId, sessionId);
+  }
+  if (sessionId) {
+    const agents = listAgents();
+    for (const agent of agents) {
+      const session = findSessionById(agent, sessionId);
+      if (session) return session;
+    }
+    return null;
+  }
+  if (agentId) {
+    return findMainSession(agentId);
+  }
+  const defaultAgent = process.env.OPENCLAW_AGENT_ID || "clawdious";
+  return findMainSession(defaultAgent);
+}
+function formatRepairResult(result, options = {}) {
+  const { dryRun = false } = options;
+  const lines = [];
+  lines.push(`Analyzing session: ${result.sessionId}`);
+  lines.push("");
+  if (result.corruptedEntries.length === 0) {
+    lines.push("\u2705 No corruption detected. Session is clean.");
+    return lines.join("\n");
+  }
+  if (dryRun) {
+    lines.push(`Found ${result.corruptedEntries.length} corrupted entries:`);
+  } else {
+    lines.push(`Found and fixed ${result.corruptedEntries.length} corrupted entries:`);
+  }
+  for (const entry of result.corruptedEntries) {
+    const prefix = entry.type === "aborted_tool_use" ? "Aborted tool_use" : "Orphaned tool_result";
+    lines.push(`  - Line ${entry.lineNumber}: ${prefix} (id: ${entry.toolUseId})`);
+  }
+  if (result.parentRelinks.length > 0) {
+    lines.push("");
+    if (dryRun) {
+      lines.push(`Would relink ${result.parentRelinks.length} parent reference(s):`);
+    } else {
+      lines.push(`Relinked ${result.parentRelinks.length} parent reference(s):`);
+    }
+    for (const relink of result.parentRelinks.slice(0, 5)) {
+      lines.push(`  - Line ${relink.lineNumber}: parentId ${relink.oldParentId.slice(0, 8)}\u2026 \u2192 ${relink.newParentId === "null" ? "null" : relink.newParentId.slice(0, 8)}\u2026`);
+    }
+    if (result.parentRelinks.length > 5) {
+      lines.push(`  ... and ${result.parentRelinks.length - 5} more`);
+    }
+  }
+  lines.push("");
+  if (dryRun) {
+    lines.push(`Would remove ${result.removedCount} entries, relink ${result.relinkedCount} parent references.`);
+  } else {
+    lines.push(`\u2705 Session repaired: removed ${result.removedCount} entries, relinked ${result.relinkedCount} parent references`);
+    if (result.backupPath) {
+      const backupName = result.backupPath.split("/").pop();
+      lines.push(`Backup saved: ${backupName}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function repairSessionCommand(options) {
+  const { backup = true, dryRun = false } = options;
+  const session = resolveSession(options);
+  if (!session) {
+    throw new Error(
+      options.sessionId ? `Session not found: ${options.sessionId}` : options.agentId ? `No main session found for agent: ${options.agentId}` : "No session found. Specify --session or --agent."
+    );
+  }
+  if (!fs.existsSync(session.filePath)) {
+    throw new Error(`Session file not found: ${session.filePath}`);
+  }
+  if (dryRun) {
+    return analyzeSession(session.filePath);
+  }
+  return repairSession(session.filePath, { backup, dryRun: false });
+}
+function listAgentSessions(agentId) {
+  const agents = agentId ? [agentId] : listAgents();
+  const lines = [];
+  if (agents.length === 0) {
+    return "No agents found in ~/.openclaw/agents/";
+  }
+  for (const agent of agents) {
+    const mainSession = findMainSession(agent);
+    if (mainSession) {
+      lines.push(`${agent}:`);
+      lines.push(`  Main session: ${mainSession.sessionId}`);
+      lines.push(`  File: ${mainSession.filePath}`);
+      if (mainSession.updatedAt) {
+        const date = new Date(mainSession.updatedAt);
+        lines.push(`  Updated: ${date.toISOString()}`);
+      }
+      lines.push("");
+    }
+  }
+  if (lines.length === 0) {
+    return agentId ? `No sessions found for agent: ${agentId}` : "No sessions found.";
+  }
+  return lines.join("\n");
+}
+export {
+  formatRepairResult,
+  listAgentSessions,
+  repairSessionCommand,
+  resolveSession
+};

package/dist/lib/session-repair.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Session transcript repair logic
+ *
+ * Repairs corrupted OpenClaw session transcripts by:
+ * 1. Finding aborted tool_use blocks (stopReason: "aborted", partialJson present)
+ * 2. Finding orphaned tool_result messages that reference non-existent tool_use IDs
+ * 3. Removing both the aborted entries and orphaned results
+ * 4. Relinking parent chain references
+ */
+interface TranscriptEntry {
+    type: 'session' | 'message' | 'compaction' | 'custom' | 'thinking_level_change' | string;
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    message?: {
+        role: 'user' | 'assistant' | 'toolResult' | 'system';
+        content: Array<{
+            type: string;
+            id?: string;
+            name?: string;
+            arguments?: unknown;
+            toolCallId?: string;
+            toolUseId?: string;
+            partialJson?: string;
+            text?: string;
+        }>;
+        stopReason?: string;
+        errorMessage?: string;
+    };
+    summary?: string;
+    customType?: string;
+    data?: unknown;
+    thinkingLevel?: string;
+}
+interface ToolUseInfo {
+    id: string;
+    lineNumber: number;
+    entryId: string;
+    isAborted: boolean;
+    isPartial: boolean;
+    name?: string;
+}
+interface CorruptedEntry {
+    lineNumber: number;
+    entryId: string;
+    type: 'aborted_tool_use' | 'orphaned_tool_result';
+    toolUseId: string;
+    description: string;
+}
+interface ParentRelink {
+    lineNumber: number;
+    entryId: string;
+    oldParentId: string;
+    newParentId: string;
+}
+interface RepairResult {
+    sessionId: string;
+    totalLines: number;
+    corruptedEntries: CorruptedEntry[];
+    parentRelinks: ParentRelink[];
+    removedCount: number;
+    relinkedCount: number;
+    backupPath?: string;
+    repaired: boolean;
+}
+/**
+ * Parse a JSONL file into transcript entries with line numbers
+ */
+declare function parseTranscript(filePath: string): Array<{
+    line: number;
+    entry: TranscriptEntry;
+    raw: string;
+}>;
+/**
+ * Extract all tool_use IDs from assistant messages
+ */
+declare function extractToolUses(entries: Array<{
+    line: number;
+    entry: TranscriptEntry;
+}>): Map<string, ToolUseInfo>;
+/**
+ * Find orphaned tool_result messages that reference non-existent or aborted tool_use IDs
+ */
+declare function findCorruptedEntries(entries: Array<{
+    line: number;
+    entry: TranscriptEntry;
+}>, toolUses: Map<string, ToolUseInfo>): {
+    corrupted: CorruptedEntry[];
+    entriesToRemove: Set<string>;
+};
+/**
+ * Compute parent chain relinks after removing entries
+ */
+declare function computeParentRelinks(entries: Array<{
+    line: number;
+    entry: TranscriptEntry;
+}>, entriesToRemove: Set<string>): ParentRelink[];
+/**
+ * Analyze a session transcript for corruption without modifying it
+ */
+declare function analyzeSession(filePath: string): RepairResult;
+/**
+ * Repair a session transcript
+ */
+declare function repairSession(filePath: string, options?: {
+    backup?: boolean;
+    dryRun?: boolean;
+}): RepairResult;
+
+export { type CorruptedEntry, type ParentRelink, type RepairResult, type ToolUseInfo, type TranscriptEntry, analyzeSession, computeParentRelinks, extractToolUses, findCorruptedEntries, parseTranscript, repairSession };

package/dist/lib/session-repair.js

@@ -0,0 +1,16 @@
+import {
+  analyzeSession,
+  computeParentRelinks,
+  extractToolUses,
+  findCorruptedEntries,
+  parseTranscript,
+  repairSession
+} from "../chunk-L53L5FCL.js";
+export {
+  analyzeSession,
+  computeParentRelinks,
+  extractToolUses,
+  findCorruptedEntries,
+  parseTranscript,
+  repairSession
+};

package/dist/lib/session-utils.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Session discovery utilities for OpenClaw transcripts
+ */
+interface SessionInfo {
+    sessionId: string;
+    sessionKey: string;
+    agentId: string;
+    filePath: string;
+    updatedAt?: number;
+}
+interface SessionsStore {
+    [sessionKey: string]: {
+        sessionId: string;
+        updatedAt?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Get the OpenClaw agents directory
+ */
+declare function getOpenClawAgentsDir(): string;
+/**
+ * Get the sessions directory for an agent
+ */
+declare function getSessionsDir(agentId: string): string;
+/**
+ * Get the path to sessions.json for an agent
+ */
+declare function getSessionsJsonPath(agentId: string): string;
+/**
+ * Get the path to a session JSONL file
+ */
+declare function getSessionFilePath(agentId: string, sessionId: string): string;
+/**
+ * List all available agents
+ */
+declare function listAgents(): string[];
+/**
+ * Load sessions.json for an agent
+ */
+declare function loadSessionsStore(agentId: string): SessionsStore | null;
+/**
+ * Find the current/main session for an agent
+ */
+declare function findMainSession(agentId: string): SessionInfo | null;
+/**
+ * Find a session by ID
+ */
+declare function findSessionById(agentId: string, sessionId: string): SessionInfo | null;
+/**
+ * List all sessions for an agent
+ */
+declare function listSessions(agentId: string): SessionInfo[];
+/**
+ * Create a backup of a session file
+ */
+declare function backupSession(filePath: string): string;
+
+export { type SessionInfo, type SessionsStore, backupSession, findMainSession, findSessionById, getOpenClawAgentsDir, getSessionFilePath, getSessionsDir, getSessionsJsonPath, listAgents, listSessions, loadSessionsStore };

package/dist/lib/session-utils.js

@@ -0,0 +1,24 @@
+import {
+  backupSession,
+  findMainSession,
+  findSessionById,
+  getOpenClawAgentsDir,
+  getSessionFilePath,
+  getSessionsDir,
+  getSessionsJsonPath,
+  listAgents,
+  listSessions,
+  loadSessionsStore
+} from "../chunk-AZRV2I5U.js";
+export {
+  backupSession,
+  findMainSession,
+  findSessionById,
+  getOpenClawAgentsDir,
+  getSessionFilePath,
+  getSessionsDir,
+  getSessionsJsonPath,
+  listAgents,
+  listSessions,
+  loadSessionsStore
+};

package/hooks/clawvault/handler.js

@@ -4,17 +4,54 @@
  * Provides automatic context death resilience:
  * - gateway:startup → detect context death, inject recovery info
  * - command:new → auto-checkpoint before session reset
+ * 
+ * SECURITY: Uses execFileSync (no shell) to prevent command injection
  */
 
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 
+// Sanitize string for safe display (prevent prompt injection via control chars)
+function sanitizeForDisplay(str) {
+  if (typeof str !== 'string') return '';
+  // Remove control characters, limit length, escape markdown
+  return str
+    .replace(/[\x00-\x1f\x7f]/g, '') // Remove control chars
+    .replace(/[`*_~\[\]]/g, '\\$&')  // Escape markdown
+    .slice(0, 200);                   // Limit length
+}
+
+// Validate vault path - must be absolute and exist
+function validateVaultPath(vaultPath) {
+  if (!vaultPath || typeof vaultPath !== 'string') return null;
+  
+  // Resolve to absolute path
+  const resolved = path.resolve(vaultPath);
+  
+  // Must be absolute
+  if (!path.isAbsolute(resolved)) return null;
+  
+  // Must exist and be a directory
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  
+  // Must contain .clawvault.json
+  const configPath = path.join(resolved, '.clawvault.json');
+  if (!fs.existsSync(configPath)) return null;
+  
+  return resolved;
+}
+
 // Find vault by walking up directories
 function findVaultPath() {
   // Check env first
   if (process.env.CLAWVAULT_PATH) {
-    return process.env.CLAWVAULT_PATH;
+    return validateVaultPath(process.env.CLAWVAULT_PATH);
   }
 
   // Walk up from cwd
@@ -22,28 +59,31 @@ function findVaultPath() {
   const root = path.parse(dir).root;
   
   while (dir !== root) {
-    const configPath = path.join(dir, '.clawvault.json');
-    if (fs.existsSync(configPath)) {
-      return dir;
-    }
+    const validated = validateVaultPath(dir);
+    if (validated) return validated;
+    
     // Also check memory/ subdirectory (OpenClaw convention)
-    const memoryConfig = path.join(dir, 'memory', '.clawvault.json');
-    if (fs.existsSync(memoryConfig)) {
-      return path.join(dir, 'memory');
-    }
+    const memoryDir = path.join(dir, 'memory');
+    const memoryValidated = validateVaultPath(memoryDir);
+    if (memoryValidated) return memoryValidated;
+    
     dir = path.dirname(dir);
   }
   
   return null;
 }
 
-// Run clawvault command
+// Run clawvault command safely (no shell)
 function runClawvault(args) {
   try {
-    const output = execSync(`clawvault ${args.join(' ')}`, {
+    // Use execFileSync to avoid shell injection
+    // Arguments are passed as array, not interpolated into shell
+    const output = execFileSync('clawvault', args, {
       encoding: 'utf-8',
       timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe']
+      stdio: ['pipe', 'pipe', 'pipe'],
+      // Explicitly no shell
+      shell: false
     });
     return { success: true, output: output.trim(), code: 0 };
   } catch (err) {
@@ -55,6 +95,31 @@ function runClawvault(args) {
   }
 }
 
+// Parse recovery output safely
+function parseRecoveryOutput(output) {
+  if (!output || typeof output !== 'string') {
+    return { hadDeath: false, workingOn: null };
+  }
+  
+  const hadDeath = output.includes('Context death detected') || 
+                   output.includes('died') || 
+                   output.includes('⚠️');
+  
+  let workingOn = null;
+  if (hadDeath) {
+    const lines = output.split('\n');
+    const workingOnLine = lines.find(l => l.toLowerCase().includes('working on'));
+    if (workingOnLine) {
+      const parts = workingOnLine.split(':');
+      if (parts.length > 1) {
+        workingOn = sanitizeForDisplay(parts.slice(1).join(':').trim());
+      }
+    }
+  }
+  
+  return { hadDeath, workingOn };
+}
+
 // Handle gateway startup - check for context death
 async function handleStartup(event) {
   const vaultPath = findVaultPath();
@@ -63,36 +128,34 @@ async function handleStartup(event) {
     return;
   }
 
-  console.log(`[clawvault] Checking for context death (vault: ${vaultPath})`);
+  console.log(`[clawvault] Checking for context death`);
 
+  // Pass vault path as separate argument (not interpolated)
   const result = runClawvault(['recover', '--clear', '-v', vaultPath]);
   
   if (!result.success) {
-    console.warn('[clawvault] Recovery check failed:', result.output);
+    console.warn('[clawvault] Recovery check failed');
     return;
   }
 
-  // Parse output to detect if there was a death
-  const output = result.output;
+  const { hadDeath, workingOn } = parseRecoveryOutput(result.output);
   
-  if (output.includes('Context death detected') || output.includes('died') || output.includes('⚠️')) {
-    // Extract relevant info
-    const lines = output.split('\n');
-    const workingOnLine = lines.find(l => l.toLowerCase().includes('working on'));
-    const workingOn = workingOnLine ? workingOnLine.split(':').slice(1).join(':').trim() : null;
+  if (hadDeath) {
+    // Build safe alert message with sanitized content
+    const alertParts = ['[ClawVault] Context death detected.'];
+    if (workingOn) {
+      alertParts.push(`Last working on: ${workingOn}`);
+    }
+    alertParts.push('Run `clawvault wake` for full recovery context.');
     
-    const alertMsg = [
-      '⚠️ **Context Death Detected**',
-      workingOn ? `Last working on: ${workingOn}` : null,
-      'Run `clawvault wake` for full recovery context.'
-    ].filter(Boolean).join('\n');
+    const alertMsg = alertParts.join(' ');
 
     // Inject into event messages if available
     if (event.messages && Array.isArray(event.messages)) {
       event.messages.push(alertMsg);
     }
     
-    console.warn('[clawvault] ⚠️ Context death detected, alert injected');
+    console.warn('[clawvault] Context death detected, alert injected');
   } else {
     console.log('[clawvault] Clean startup - no context death');
   }
@@ -106,24 +169,28 @@ async function handleNew(event) {
     return;
   }
 
-  // Build checkpoint info from event context
-  const sessionKey = event.sessionKey || 'unknown';
-  const source = event.context?.commandSource || 'cli';
-  const workingOn = `Session reset via /new from ${source}`;
+  // Sanitize session info for checkpoint
+  const sessionKey = typeof event.sessionKey === 'string' 
+    ? event.sessionKey.replace(/[^a-zA-Z0-9:_-]/g, '').slice(0, 100)
+    : 'unknown';
+  const source = typeof event.context?.commandSource === 'string'
+    ? event.context.commandSource.replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 50)
+    : 'cli';
 
-  console.log(`[clawvault] Auto-checkpoint before /new (session: ${sessionKey})`);
+  console.log('[clawvault] Auto-checkpoint before /new');
 
+  // Pass each argument separately (no shell interpolation)
   const result = runClawvault([
     'checkpoint',
-    '--working-on', `"${workingOn}"`,
-    '--focus', `"Pre-reset checkpoint, session: ${sessionKey}"`,
+    '--working-on', `Session reset via /new from ${source}`,
+    '--focus', `Pre-reset checkpoint, session: ${sessionKey}`,
     '-v', vaultPath
   ]);
 
   if (result.success) {
     console.log('[clawvault] Auto-checkpoint created');
   } else {
-    console.warn('[clawvault] Auto-checkpoint failed:', result.output);
+    console.warn('[clawvault] Auto-checkpoint failed');
   }
 }
 
@@ -140,7 +207,7 @@ const handler = async (event) => {
       return;
     }
   } catch (err) {
-    console.error('[clawvault] Hook error:', err);
+    console.error('[clawvault] Hook error:', err.message || 'unknown error');
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawvault",
-  "version": "1.4.2",
+  "version": "1.5.1",
   "description": "🐘 An elephant never forgets. Structured memory for OpenClaw agents. Context death resilience, Obsidian-compatible markdown, local semantic search.",
   "type": "module",
   "main": "dist/index.cjs",
@@ -28,7 +28,7 @@
     ]
   },
   "scripts": {
-    "build": "tsup src/index.ts src/commands/entities.ts src/commands/link.ts src/commands/checkpoint.ts src/commands/recover.ts src/commands/status.ts src/commands/template.ts src/commands/setup.ts src/commands/wake.ts src/commands/sleep.ts src/commands/doctor.ts src/commands/shell-init.ts src/lib/entity-index.ts src/lib/auto-linker.ts src/lib/config.ts src/lib/template-engine.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/commands/entities.ts src/commands/link.ts src/commands/checkpoint.ts src/commands/recover.ts src/commands/status.ts src/commands/template.ts src/commands/setup.ts src/commands/wake.ts src/commands/sleep.ts src/commands/doctor.ts src/commands/shell-init.ts src/commands/repair-session.ts src/lib/entity-index.ts src/lib/auto-linker.ts src/lib/config.ts src/lib/template-engine.ts src/lib/session-utils.ts src/lib/session-repair.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts src/commands/*.ts src/lib/*.ts --format esm --dts --watch",
     "lint": "eslint src",
     "typecheck": "tsc --noEmit",
@@ -65,8 +65,16 @@
     "chalk": "^5.3.0",
     "glob": "^10.3.10",
     "gray-matter": "^4.0.3",
-    "natural": "^6.10.4",
-    "qmd": "github:tobi/qmd"
+    "natural": "^6.10.4"
+  },
+  "optionalDependencies": {},
+  "peerDependencies": {
+    "qmd": "*"
+  },
+  "peerDependenciesMeta": {
+    "qmd": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/node": "^20.11.0",