praxis-agent 0.20.9 → 0.20.11

package/dist/application/top-level-agent-manager.d.ts

@@ -5,11 +5,11 @@ export interface TopLevelAgentSummary {
     pid?: number;
     id?: string;
     cwd: string;
-    kind: 'background' | 'interactive';
+    kind: 'background' | 'interactive' | 'bg' | 'daemon' | 'daemon-worker';
     startedAt: number;
     sessionId: string;
     name: string;
-    status?: 'active' | 'idle';
+    status?: 'active' | 'idle' | 'busy' | 'waiting';
     tempo?: ClaudeJobTempo;
     needs?: string;
     state?: 'working' | 'stopped' | 'failed' | 'done';

package/dist/application/top-level-agent-manager.js

@@ -87,6 +87,15 @@ function nativeClaudeSession(value) {
         ['active', 'idle'].includes(String(record.status));
     if (interactive)
         return record;
+    const daemon = Number.isSafeInteger(record.pid) &&
+        typeof record.cwd === 'string' &&
+        ['bg', 'daemon', 'daemon-worker'].includes(String(record.kind)) &&
+        Number.isSafeInteger(record.startedAt) &&
+        typeof record.sessionId === 'string' &&
+        typeof record.name === 'string' &&
+        ['busy', 'idle', 'waiting'].includes(String(record.status));
+    if (daemon)
+        return record;
     if (typeof record.id !== 'string' ||
         typeof record.cwd !== 'string' ||
         record.kind !== 'background' ||

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/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.9",
+  "version": "0.20.11",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",