@pikiloom/kernel 0.2.16 → 0.2.18

package/dist/drivers/claude.d.ts

@@ -57,6 +57,7 @@ export declare function emitClaudeImages(blocks: any[], s: any, emit: (e: Driver
 export declare function todoWriteToPlan(input: any): UniversalPlan | null;
 export declare function readClaudeTaskCreateId(ev: any, block: any): string | null;
 export declare function rebuildClaudeTaskPlan(s: any): UniversalPlan | null;
+export declare function applyTaskUpdateToTodoPlan(plan: UniversalPlan | null | undefined, taskId: string, rawStatus: string): UniversalPlan | null;
 export declare function shortToolValue(value: unknown, max?: number): string;
 export declare function summarizeToolUse(name: string, input: any): string;
 export declare function firstResultLine(content: any): string;

package/dist/drivers/claude.js

@@ -531,29 +531,41 @@ export function handleClaudeEvent(ev, s, emit) {
             const name = String(b.name || 'Tool');
             if (name === 'TodoWrite') {
                 const plan = todoWriteToPlan(b.input);
-                if (plan)
+                if (plan) {
+                    s.todoPlan = plan;
                     emit({ type: 'plan', plan });
+                }
+                const summary = 'Update plan';
+                (s.tools ||= new Map()).set(id, { name, summary });
+                emit({ type: 'tool', call: { id, name, summary, input: null, status: 'running' } });
                 continue;
             }
             // Task list (current Claude mechanism): stash the subject; the tool_result assigns the id.
-            // Plan-only — like the legacy driver these never surface as Activity rows.
+            // The command surfaces as an Activity row (matching the CLI's own transcript); the
+            // structured task state still flows through plan events.
             if (name === 'TaskCreate') {
                 const subject = typeof b.input?.subject === 'string' ? b.input.subject.trim() : '';
                 if (subject)
                     (s.pendingTaskCreates ||= new Map()).set(id, { subject });
+                const summary = subject ? `Create task: ${subject}` : 'Create task';
+                (s.tools ||= new Map()).set(id, { name, summary });
+                emit({ type: 'tool', call: { id, name, summary, input: null, status: 'running' } });
                 continue;
             }
             if (name === 'TaskUpdate') {
                 const taskId = String(b.input?.taskId ?? '').trim();
                 const rawStatus = String(b.input?.status ?? '').trim().toLowerCase();
-                if (taskId) {
+                // Chronological: the plan reflects the state AFTER this update. An id known to the
+                // TaskCreate store lands there; otherwise it lands positionally on the latest
+                // TodoWrite list (ids are 1-based positions when the todo panel owns the list).
+                if (taskId && s.taskList?.has(taskId)) {
                     if (rawStatus === 'deleted') {
-                        s.taskList?.delete(taskId);
+                        s.taskList.delete(taskId);
                         if (Array.isArray(s.taskOrder))
                             s.taskOrder = s.taskOrder.filter((x) => x !== taskId);
                     }
                     else if (rawStatus) {
-                        const existing = s.taskList?.get(taskId);
+                        const existing = s.taskList.get(taskId);
                         if (existing)
                             existing.status = rawStatus;
                     }
@@ -561,6 +573,16 @@ export function handleClaudeEvent(ev, s, emit) {
                     if (plan)
                         emit({ type: 'plan', plan });
                 }
+                else if (taskId) {
+                    const updated = applyTaskUpdateToTodoPlan(s.todoPlan, taskId, rawStatus);
+                    if (updated) {
+                        s.todoPlan = updated;
+                        emit({ type: 'plan', plan: updated });
+                    }
+                }
+                const summary = `Update task ${taskId || '?'} → ${rawStatus || 'unknown'}`;
+                (s.tools ||= new Map()).set(id, { name, summary });
+                emit({ type: 'tool', call: { id, name, summary, input: null, status: 'running' } });
                 continue;
             }
             if (name === 'Task' || name === 'Agent') {
@@ -641,13 +663,16 @@ export function handleClaudeEvent(ev, s, emit) {
                     if (plan)
                         emit({ type: 'plan', plan });
                 }
+                if (tool)
+                    emit({ type: 'tool', call: { id, name: tool.name, summary: tool.summary, status: b.is_error ? 'failed' : 'done', result: null } });
                 continue;
             }
             if (!tool)
                 continue;
             const isError = !!b.is_error;
-            // File-shaped tools have no useful result detail (mirrors pikiloom): just mark done.
-            const fileTool = tool.name === 'Read' || tool.name === 'Edit' || tool.name === 'Write' || tool.name === 'TodoWrite';
+            // File-shaped and task-list tools have no useful result detail (mirrors pikiloom): just mark done.
+            const fileTool = tool.name === 'Read' || tool.name === 'Edit' || tool.name === 'Write'
+                || tool.name === 'TodoWrite' || tool.name === 'TaskCreate' || tool.name === 'TaskUpdate';
             const detail = (isError || !fileTool) ? firstResultLine(b.content) : null;
             emit({ type: 'tool', call: { id, name: tool.name, summary: tool.summary, status: isError ? 'failed' : 'done', result: detail || null } });
         }
@@ -960,6 +985,30 @@ export function rebuildClaudeTaskPlan(s) {
     }
     return steps.length ? { explanation: null, steps } : null;
 }
+// Apply a TaskUpdate to a TodoWrite-produced plan positionally (taskId = 1-based item index).
+// Used when the id isn't in the TaskCreate store, so an update issued AFTER a TodoWrite still
+// lands on the displayed list — the plan reflects the state after the LAST change, whichever
+// mechanism wrote it. Returns a fresh plan (never mutates) or null when inapplicable.
+export function applyTaskUpdateToTodoPlan(plan, taskId, rawStatus) {
+    if (!plan || !Array.isArray(plan.steps) || !plan.steps.length)
+        return null;
+    if (!/^\d+$/.test(taskId))
+        return null;
+    const idx = Number(taskId) - 1;
+    if (idx < 0 || idx >= plan.steps.length)
+        return null;
+    if (rawStatus === 'deleted') {
+        const steps = plan.steps.filter((_, i) => i !== idx);
+        return steps.length ? { explanation: plan.explanation ?? null, steps } : null;
+    }
+    const status = rawStatus === 'completed' ? 'completed'
+        : (rawStatus === 'in_progress' || rawStatus === 'inprogress') ? 'inProgress'
+            : rawStatus === 'pending' ? 'pending' : null;
+    if (!status)
+        return null;
+    const steps = plan.steps.map((step, i) => i === idx ? { ...step, status } : step);
+    return { explanation: plan.explanation ?? null, steps };
+}
 // ── Tool-call summarization (ported from pikiloom's summarizeClaudeToolUse) ──────────
 // Turns a Claude tool_use {name,input} into a one-line human summary. The runtime's
 // activity projector joins these into snapshot.activity; the structured form lives in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikiloom/kernel",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "Heterogeneous coding agents (Claude / Codex / Gemini / ACP) -> an interaction-friendly, accumulating session snapshot + control handle, over pluggable surfaces (IM, Web, tunnel, TUI). The reusable core pikiloom itself is built on.",
   "type": "module",
   "license": "MIT",