pikiloom 0.4.42 → 0.4.43

package/dist/agent/kernel-bridge.js

@@ -109,6 +109,22 @@ function buildKernelDriver(kernel, opts) {
             };
     }
 }
+// Kernel plan steps key their text as { text }; pikiloom's StreamPlan and the entire dashboard
+// pipeline (pikichannel adapter -> ws.ts -> PlanProgressCard) key it as { step }. Translate at
+// this seam — the same place we already remap usage fields — so codex/claude task lists render
+// their text. Without it the progress count ("0/4") shows but every row is blank (the card reads
+// step.step, which is undefined on the kernel shape).
+export function toPikiloomPlan(plan) {
+    if (!plan || !Array.isArray(plan.steps))
+        return null;
+    const steps = plan.steps
+        .map((st) => ({
+        step: typeof st?.text === 'string' ? st.text : typeof st?.step === 'string' ? st.step : '',
+        status: (st?.status === 'completed' ? 'completed' : st?.status === 'inProgress' ? 'inProgress' : 'pending'),
+    }))
+        .filter((st) => st.step.trim());
+    return steps.length ? { explanation: typeof plan.explanation === 'string' ? plan.explanation : null, steps } : null;
+}
 let _kernel = null;
 export async function loadKernel() {
     if (_kernel)
@@ -185,7 +201,7 @@ export async function kernelStream(opts) {
             providerName: opts.byokProviderName ?? null,
         };
         try {
-            opts.onText(s.text || '', s.reasoning || '', s.activity || '', m, s.plan ?? null);
+            opts.onText(s.text || '', s.reasoning || '', s.activity || '', m, toPikiloomPlan(s.plan));
         }
         catch { /* isolate */ }
     };
@@ -229,7 +245,7 @@ export async function kernelStream(opts) {
         ok: !!result.ok,
         message: (result.text || snapshot.text || '').trim() || (finalError ?? '(no output)'),
         thinking: (result.reasoning || snapshot.reasoning || '').trim() || null,
-        plan: snapshot.plan ?? null,
+        plan: toPikiloomPlan(snapshot.plan),
         sessionId: finalSessionId,
         workspacePath: null,
         model: input.model ?? null,

package/dist/dashboard/routes/accounts.js

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
 import { allDriverIds } from '../../agent/index.js';
 import { accountAgentSupported, listAccounts, getAccount, addAccount, updateAccount, removeAccount, getActiveAccountId, setActiveAccount, probeAccountUsage, MAX_ACCOUNTS_PER_AGENT, } from '../../agent/accounts.js';
+import { invalidateAgentStatus } from './agents.js';
 const app = new Hono();
 function agentError(agent) {
     if (!allDriverIds().includes(agent))
@@ -104,6 +105,12 @@ app.post('/api/agents/:agent/active-account', async (c) => {
         return c.json({ ok: false, error: 'accountId (string|null) is required' }, 400);
     try {
         setActiveAccount(agent, accountId);
+        // The identity that drives usage just changed: drop the cached agent-status (its native /
+        // default-login usage is now stale) and force-refresh the newly-active account's own usage,
+        // so the header reflects the latest numbers immediately instead of the previous account's.
+        if (accountId)
+            await probeAccountUsage(agent, accountId, { force: true });
+        await invalidateAgentStatus();
         return c.json({ ok: true, agent, activeAccountId: accountId });
     }
     catch (e) {

package/dist/dashboard/routes/agents.js

@@ -238,7 +238,7 @@ function getCachedAgentStatus() {
     }
     return refreshStatusCache();
 }
-function invalidateAgentStatus(config, opts) {
+export function invalidateAgentStatus(config, opts) {
     statusCache.pending = null;
     return refreshStatusCache(config, opts);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.42",
+  "version": "0.4.43",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/dist/drivers/claude.d.ts

@@ -30,9 +30,11 @@ export declare function claudeUsageOf(s: ClaudeUsageState): UniversalUsage;
 export declare function claudeContextWindowFromModel(model: unknown): number | null;
 export declare function claudeEffectiveContextWindow(advertised: number | null): number | null;
 export declare function handleClaudeEvent(ev: any, s: any, emit: (e: DriverEvent) => void): void;
-export declare function claudeUserMessage(text: string): string;
+export declare function claudeUserMessage(text: string, attachments?: string[]): string;
 export declare function emitClaudeImages(blocks: any[], s: any, emit: (e: DriverEvent) => void): void;
 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 shortToolValue(value: unknown, max?: number): string;
 export declare function summarizeToolUse(name: string, input: any): string;
 export declare function firstResultLine(content: any): string;

package/packages/kernel/dist/drivers/claude.js

@@ -1,4 +1,6 @@
 import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { extname } from 'node:path';
 import { discoverClaudeNativeSessions } from '../workspace/native.js';
 // Real driver: shells the local `claude` CLI in stream-json mode and normalizes its
 // events into kernel DriverEvents. Faithful to pikiloom's claude.ts event shapes
@@ -28,6 +30,9 @@ export class ClaudeDriver {
     }
     run(input, ctx) {
         const steerable = !!input.steerable;
+        // Image attachments must ride a stream-json user message (text-only stdin can't carry images),
+        // so enable that input mode whenever there are attachments, not just for mid-turn steering.
+        const useStreamJson = steerable || !!input.attachments?.length;
         const args = ['-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
         if (input.model)
             args.push('--model', input.model);
@@ -41,8 +46,10 @@ export class ClaudeDriver {
             args.push('--mcp-config', input.mcpConfigPath);
         if (input.permissionMode)
             args.push('--permission-mode', input.permissionMode); // parity: keep bypass/accept-edits on the kernel path
+        if (useStreamJson)
+            args.push('--input-format', 'stream-json');
         if (steerable)
-            args.push('--input-format', 'stream-json', '--replay-user-messages'); // parity: mid-turn steer
+            args.push('--replay-user-messages'); // parity: mid-turn steer
         if (input.extraArgs?.length)
             args.push(...input.extraArgs);
         const state = {
@@ -54,6 +61,9 @@ export class ClaudeDriver {
             contextWindow: null, turnOutputTokensBase: 0,
             subAgents: new Map(),
             tools: new Map(),
+            taskList: new Map(),
+            taskOrder: [],
+            pendingTaskCreates: new Map(),
         };
         return new Promise((resolve) => {
             let child;
@@ -90,9 +100,9 @@ export class ClaudeDriver {
             else
                 ctx.signal.addEventListener('abort', onAbort, { once: true });
             if (steerable) {
-                ctx.registerSteer(async (prompt) => {
+                ctx.registerSteer(async (prompt, attachments) => {
                     try {
-                        child.stdin.write(claudeUserMessage(prompt) + '\n');
+                        child.stdin.write(claudeUserMessage(prompt, attachments) + '\n');
                         return true;
                     }
                     catch {
@@ -136,8 +146,11 @@ export class ClaudeDriver {
                 finish({ ok, text: state.text, reasoning: state.reasoning || undefined, error: state.error || (ok ? null : `claude exited ${code}${stderr ? `: ${stderr.slice(0, 300)}` : ''}`), stopReason: state.stopReason, sessionId: state.sessionId, usage: usageOf() });
             });
             try {
-                if (steerable)
-                    child.stdin.write(claudeUserMessage(input.prompt) + '\n'); // keep stdin open for steering
+                if (useStreamJson) {
+                    child.stdin.write(claudeUserMessage(input.prompt, input.attachments) + '\n');
+                    if (!steerable)
+                        child.stdin.end(); // single turn; steer mode keeps stdin open for replay
+                }
                 else {
                     child.stdin.write(input.prompt);
                     child.stdin.end();
@@ -301,6 +314,34 @@ export function handleClaudeEvent(ev, s, emit) {
                     emit({ type: 'plan', plan });
                 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.
+            if (name === 'TaskCreate') {
+                const subject = typeof b.input?.subject === 'string' ? b.input.subject.trim() : '';
+                if (subject)
+                    (s.pendingTaskCreates ||= new Map()).set(id, { subject });
+                continue;
+            }
+            if (name === 'TaskUpdate') {
+                const taskId = String(b.input?.taskId ?? '').trim();
+                const rawStatus = String(b.input?.status ?? '').trim().toLowerCase();
+                if (taskId) {
+                    if (rawStatus === 'deleted') {
+                        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);
+                        if (existing)
+                            existing.status = rawStatus;
+                    }
+                    const plan = rebuildClaudeTaskPlan(s);
+                    if (plan)
+                        emit({ type: 'plan', plan });
+                }
+                continue;
+            }
             if (name === 'Task' || name === 'Agent') {
                 const input = b.input || {};
                 const sub = {
@@ -348,6 +389,23 @@ export function handleClaudeEvent(ev, s, emit) {
                 continue;
             emitClaudeImages(b.content || [], s, emit);
             const id = String(b.tool_use_id || '').trim();
+            // TaskCreate result: the assigned task id arrives here; register the task and emit the plan.
+            if (id && s.pendingTaskCreates?.has(id)) {
+                const pending = s.pendingTaskCreates.get(id);
+                const assignedId = readClaudeTaskCreateId(ev, b);
+                if (pending && assignedId) {
+                    s.pendingTaskCreates.delete(id);
+                    (s.taskList ||= new Map());
+                    (s.taskOrder ||= []);
+                    if (!s.taskList.has(assignedId))
+                        s.taskOrder.push(assignedId);
+                    s.taskList.set(assignedId, { subject: pending.subject, status: 'pending' });
+                    const plan = rebuildClaudeTaskPlan(s);
+                    if (plan)
+                        emit({ type: 'plan', plan });
+                }
+                continue;
+            }
             const tool = id ? s.tools?.get(id) : undefined;
             if (!tool)
                 continue;
@@ -384,10 +442,30 @@ export function handleClaudeEvent(ev, s, emit) {
         return;
     }
 }
-// A stream-json user message (for --input-format stream-json; used to send the prompt and
-// to inject mid-turn steer messages while stdin stays open).
-export function claudeUserMessage(text) {
-    return JSON.stringify({ type: 'user', message: { role: 'user', content: [{ type: 'text', text }] } });
+// Claude vision input formats (matches the legacy driver / Anthropic API: png, jpeg, gif, webp).
+const CLAUDE_IMAGE_MIME = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp',
+};
+// A stream-json user message (for --input-format stream-json; used to send the prompt and to
+// inject mid-turn steer messages while stdin stays open). Image attachments are inlined as base64
+// image content blocks so the model actually sees them; other files become a text note. Without
+// this the kernel path sent text only and silently dropped pasted/attached images.
+export function claudeUserMessage(text, attachments) {
+    const content = [];
+    for (const filePath of attachments || []) {
+        const mime = CLAUDE_IMAGE_MIME[extname(filePath).toLowerCase()];
+        if (mime) {
+            try {
+                content.push({ type: 'image', source: { type: 'base64', media_type: mime, data: readFileSync(filePath).toString('base64') } });
+                continue;
+            }
+            catch { /* unreadable -> fall through to a text note */ }
+        }
+        content.push({ type: 'text', text: `[Attached file: ${filePath}]` });
+    }
+    content.push({ type: 'text', text });
+    return JSON.stringify({ type: 'user', message: { role: 'user', content } });
 }
 // Surface base64 image content blocks as artifacts (data URLs), deduped per turn.
 export function emitClaudeImages(blocks, s, emit) {
@@ -425,6 +503,45 @@ export function todoWriteToPlan(input) {
     }
     return steps.length ? { explanation: null, steps } : null;
 }
+// ── Claude task-list (TaskCreate / TaskUpdate) -> UniversalPlan ──────────────────────
+// Current Claude Code drives its task list through TaskCreate/TaskUpdate, NOT TodoWrite
+// (TodoWrite is the legacy mechanism). TaskCreate carries the subject; its tool_result then
+// assigns a stable task id (toolUseResult.task.id, or "Task #N" in the text). TaskUpdate flips
+// a task's status by id. We accumulate the list in driver state and re-emit the whole plan on
+// each change. Without this the kernel path never emits a plan event for Claude, so the
+// dashboard's task-list card never renders. Ported from pikiloom's legacy claude driver.
+// The assigned task id from a TaskCreate tool_result. Prefer the structured field; fall back
+// to parsing "Task #N" from a string result.
+export function readClaudeTaskCreateId(ev, block) {
+    const structured = ev?.toolUseResult?.task?.id;
+    if (structured != null && String(structured).trim())
+        return String(structured).trim();
+    const content = block?.content;
+    if (typeof content === 'string') {
+        const m = content.match(/Task #(\d+)/);
+        if (m)
+            return m[1];
+    }
+    return null;
+}
+export function rebuildClaudeTaskPlan(s) {
+    if (!Array.isArray(s?.taskOrder) || !s.taskOrder.length)
+        return null;
+    const steps = [];
+    for (const id of s.taskOrder) {
+        const task = s.taskList?.get(id);
+        if (!task)
+            continue;
+        const lowered = String(task.status || '').toLowerCase();
+        const status = lowered === 'completed' ? 'completed'
+            : (lowered === 'in_progress' || lowered === 'inprogress') ? 'inProgress'
+                : 'pending';
+        const text = String(task.subject || '').trim();
+        if (text)
+            steps.push({ text, status });
+    }
+    return steps.length ? { explanation: null, steps } : null;
+}
 // ── 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/packages/kernel/dist/drivers/codex.js

@@ -241,7 +241,21 @@ export class CodexDriver {
         const ok = await srv.start();
         if (!ok)
             return { ok: false, text: '', error: 'failed to start codex app-server', stopReason: 'error' };
-        const onAbort = () => srv.kill();
+        let settle = () => { };
+        const turnDone = new Promise((res) => { settle = res; });
+        // On abort: gracefully interrupt the running turn, then settle turnDone OURSELVES. A bare
+        // srv.kill() (SIGTERM) never produces a turn/completed notification, so without this explicit
+        // settle() the `await turnDone` below hangs forever — run() never resolves and the task stays
+        // "running" in the orchestrator even though the codex process is already dead ("停止不掉，但实际上已经停了").
+        const onAbort = () => {
+            if (state.sessionId && state.turnId) {
+                srv.call('turn/interrupt', { threadId: state.sessionId, turnId: state.turnId }, 5_000).finally(() => settle());
+            }
+            else {
+                srv.kill();
+                settle();
+            }
+        };
         if (ctx.signal.aborted)
             onAbort();
         else
@@ -264,8 +278,6 @@ export class CodexDriver {
                 state.sessionId = threadId;
                 ctx.emit({ type: 'session', sessionId: threadId });
             }
-            let settle = () => { };
-            const turnDone = new Promise((res) => { settle = res; });
             srv.onNotification((method, params) => {
                 if (params?.threadId && params.threadId !== state.sessionId && method !== 'turn/started')
                     return;