praxis-agent 0.20.8 → 0.20.10

package/dist/cli/tui/hook-settings.js

@@ -1,9 +1,10 @@
+import { HOOK_EVENTS, } from '../../hooks/claude-hooks.js';
 export const TUI_HOOK_MENU = {
     title: 'Hooks',
     readOnlyNotice: 'This menu is read-only. To add or modify hooks, edit settings.json directly or ask Claude.',
     visibleRows: 5,
 };
-export const TUI_HOOK_EVENTS = [
+const TUI_HOOK_EVENT_DEFINITIONS = [
     {
         name: 'PreToolUse',
         description: 'Before tool execution',
@@ -109,6 +110,7 @@ export const TUI_HOOK_EVENTS = [
         detail: [],
     },
 ];
+export const TUI_HOOK_EVENTS = TUI_HOOK_EVENT_DEFINITIONS.filter((definition) => HOOK_EVENTS.includes(definition.name));
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/compatibility/claude/tool-links.d.ts

@@ -5,6 +5,7 @@ export declare function indexClaudeToolLinks(entries: readonly ClaudeTranscriptE
     toolNames: Map<string, string>;
     completedToolCalls: Set<string>;
 };
+export declare function recoverClaudeToolResultLinks(entries: readonly ClaudeTranscriptEntry[]): ClaudeTranscriptEntry[];
 export declare function findUnresolvedClaudeToolCalls(entries: readonly ClaudeTranscriptEntry[]): {
     id: string;
     name: string;

package/dist/compatibility/claude/tool-links.js

@@ -33,6 +33,82 @@ export function indexClaudeToolLinks(entries) {
     }
     return { toolCalls, toolNames, completedToolCalls };
 }
+export function recoverClaudeToolResultLinks(entries) {
+    // Index each tool_use id to the uuid of its unique assistant entry. An id
+    // declared by more than one assistant tool_use block, or by an assistant
+    // entry without a string uuid, is ambiguous and is never recoverable.
+    const assistantUuidById = new Map();
+    const assistantIdCounts = new Map();
+    for (const entry of entries) {
+        if (entry.type !== 'assistant')
+            continue;
+        for (const block of getClaudeContentBlocks(entry)) {
+            if (block.type !== 'tool_use' || typeof block.id !== 'string')
+                continue;
+            const count = (assistantIdCounts.get(block.id) ?? 0) + 1;
+            assistantIdCounts.set(block.id, count);
+            if (count === 1 && typeof entry.uuid === 'string') {
+                assistantUuidById.set(block.id, entry.uuid);
+            }
+            else {
+                assistantUuidById.delete(block.id);
+            }
+        }
+    }
+    // Count every tool_result reference so a recovered link never duplicates a
+    // result that was already completed elsewhere in the transcript.
+    const resultIdCounts = new Map();
+    for (const entry of entries) {
+        if (entry.type !== 'user')
+            continue;
+        for (const block of getClaudeContentBlocks(entry)) {
+            if (block.type !== 'tool_result' ||
+                typeof block.tool_use_id !== 'string') {
+                continue;
+            }
+            resultIdCounts.set(block.tool_use_id, (resultIdCounts.get(block.tool_use_id) ?? 0) + 1);
+        }
+    }
+    const recovered = [];
+    for (const entry of entries) {
+        if (entry.type === 'user' &&
+            typeof entry.sourceToolAssistantUUID !== 'string') {
+            const blocks = getClaudeContentBlocks(entry).filter((block) => block.type === 'tool_result');
+            const sourceUuids = new Set();
+            let linkable = true;
+            for (const block of blocks) {
+                // Malformed tool_result blocks (non-string tool_use_id) are never
+                // recovered and prevent linking the whole entry.
+                if (typeof block.tool_use_id !== 'string') {
+                    linkable = false;
+                    break;
+                }
+                const sourceUuid = assistantUuidById.get(block.tool_use_id);
+                if (sourceUuid === undefined ||
+                    resultIdCounts.get(block.tool_use_id) !== 1) {
+                    linkable = false;
+                    break;
+                }
+                sourceUuids.add(sourceUuid);
+                // A single entry has one sourceToolAssistantUUID, so every recoverable
+                // block must resolve to the same assistant entry.
+                if (sourceUuids.size > 1) {
+                    linkable = false;
+                    break;
+                }
+            }
+            if (linkable && sourceUuids.size === 1) {
+                recovered.push({
+                    ...entry,
+                    sourceToolAssistantUUID: [...sourceUuids][0],
+                });
+                continue;
+            }
+        }
+        recovered.push(entry);
+    }
+    return recovered;
+}
 export function findUnresolvedClaudeToolCalls(entries) {
     const active = selectClaudeActiveTranscript(entries);
     const { completedToolCalls } = indexClaudeToolLinks(active);

package/dist/hooks/claude-hooks.d.ts

@@ -72,6 +72,7 @@ export interface ClaudeHookRunnerOptions {
     executeCommand?: ClaudeHookCommandExecutor;
     onEvent?: (event: ClaudeHookStreamEvent) => void;
 }
+export declare const HOOK_EVENTS: readonly ClaudeHookEventName[];
 export declare function validateClaudeHooks(settings: readonly ClaudeJsonResource[], maxTimeoutMs?: number): void;
 export declare class ClaudeHookRunner {
     private readonly settings;

package/dist/hooks/claude-hooks.js

@@ -4,7 +4,7 @@ import { redactSensitiveText, sanitizeChildEnvironment, sensitiveEnvironmentValu
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_MAX_OUTPUT_BYTES = 128 * 1024;
 const KILL_GRACE_MS = 250;
-const HOOK_EVENTS = [
+export const HOOK_EVENTS = [
     'Setup',
     'SessionStart',
     'SubagentStart',

package/dist/persistence/claude-transcript-store.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { mkdir, open, readFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { TextDecoder } from 'node:util';
-import { getClaudeContentBlocks, indexClaudeToolLinks, } from '../compatibility/claude/tool-links.js';
+import { getClaudeContentBlocks, indexClaudeToolLinks, recoverClaudeToolResultLinks, } from '../compatibility/claude/tool-links.js';
 import { ExclusiveFileLease } from '../platform/exclusive-file-lease.js';
 export class ClaudeTranscriptParseError extends Error {
     lineNumber;
@@ -200,10 +200,14 @@ export class ClaudeTranscriptStore {
     }
     async load() {
         const { entries, tail } = this.parseSource(await this.readSource(), false);
-        return { entries, tail };
+        return { entries: recoverClaudeToolResultLinks(entries), tail };
     }
     async loadReadOnly() {
-        return this.parseSource(await this.readSource(), true);
+        const recovery = this.parseSource(await this.readSource(), true);
+        return {
+            ...recovery,
+            entries: recoverClaudeToolResultLinks(recovery.entries),
+        };
     }
     async exportReadOnly() {
         return readFile(this.sessionFile);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.20.8",
+  "version": "0.20.10",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",