pikiloom 0.4.41 → 0.4.43

package/dist/agent/drivers/claude.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { registerDriver } from '../driver.js';
-import { Q, run, agentError, agentLog, agentWarn, buildStreamPreviewMeta, computeContext, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, joinErrorMessages, parseTodoWriteAsPlan, previewToolCallInput, previewToolCallResult, detectClaudeApiError, isRetryableClaudeApiError, detectClaudeModelError, claudeModelErrorMessage, emitSessionIdUpdate, IMAGE_EXTS, mimeForExt, listPikiloomSessions, mergeManagedAndNativeSessions, managedRecordToSessionInfo, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, attachAgentImage, applyTurnWindow, shortValue, roundPercent, modelFamily, normalizeClaudeModelId, emptyUsage, normalizeUsageStatus, collapseSkillPrompt, } from '../index.js';
+import { Q, run, agentError, agentLog, agentWarn, buildStreamPreviewMeta, computeContext, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, joinErrorMessages, parseTodoWriteAsPlan, previewToolCallInput, previewToolCallResult, detectClaudeApiError, isRetryableClaudeApiError, detectClaudeModelError, claudeModelErrorMessage, emitSessionIdUpdate, IMAGE_EXTS, mimeForExt, listPikiloomSessions, mergeManagedAndNativeSessions, managedRecordToSessionInfo, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, attachAgentImage, applyTurnWindow, shortValue, roundPercent, toIsoFromEpochSeconds, modelFamily, normalizeClaudeModelId, emptyUsage, normalizeUsageStatus, collapseSkillPrompt, } from '../index.js';
 import { AGENT_STREAM_HARD_KILL_GRACE_MS, AGENT_GRACEFUL_ABORT_GRACE_MS, SESSION_RUNNING_THRESHOLD_MS } from '../../core/constants.js';
 import { terminateProcessTree } from '../../core/process-control.js';
 import { getHome, IS_MAC, encodePathAsDirName } from '../../core/platform.js';
@@ -1775,54 +1775,187 @@ function getClaudeOAuthToken() {
         return null;
     }
 }
-function getClaudeUsageFromOAuth() {
-    const token = getClaudeOAuthToken();
+// Shape the `/api/oauth/usage` JSON into a UsageResult (shared by the sync curl probe and the
+// async fetch probe). Returns null on an API error payload or when no usable window is present.
+function buildClaudeOAuthUsage(data) {
+    const apiError = data?.error;
+    if (apiError && typeof apiError === 'object')
+        return null;
+    const makeWindow = (label, entry) => {
+        if (!entry || typeof entry !== 'object')
+            return null;
+        const usedPercent = roundPercent(entry.utilization);
+        if (usedPercent == null)
+            return null;
+        const remainingPercent = Math.max(0, Math.round((100 - usedPercent) * 10) / 10);
+        const resetAt = typeof entry.resets_at === 'string' ? entry.resets_at : null;
+        let resetAfterSeconds = null;
+        if (resetAt) {
+            const resetAtMs = Date.parse(resetAt);
+            if (Number.isFinite(resetAtMs))
+                resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
+        }
+        return {
+            label, usedPercent, remainingPercent, resetAt, resetAfterSeconds,
+            status: usedPercent >= 100 ? 'limit_reached' : usedPercent >= 80 ? 'warning' : 'allowed',
+        };
+    };
+    const windows = [];
+    for (const [label, key] of [['5h', 'five_hour'], ['7d', 'seven_day'], ['7d Opus', 'seven_day_opus'], ['7d Sonnet', 'seven_day_sonnet'], ['Extra', 'extra_usage']]) {
+        const w = makeWindow(label, data[key]);
+        if (w)
+            windows.push(w);
+    }
+    if (!windows.length)
+        return null;
+    const overallStatus = windows.some(w => w.status === 'limit_reached') ? 'limit_reached'
+        : windows.some(w => w.status === 'warning') ? 'warning' : 'allowed';
+    return { ok: true, agent: 'claude', source: 'oauth-api', capturedAt: new Date().toISOString(), status: overallStatus, windows, error: null };
+}
+function getClaudeUsageFromOAuth(tokenOverride) {
+    const token = tokenOverride || getClaudeOAuthToken();
     if (!token)
         return null;
     try {
         const raw = execSync(`curl -s --max-time 5 -H "Authorization: Bearer ${token}" -H "anthropic-beta: oauth-2025-04-20" -H "Content-Type: application/json" "https://api.anthropic.com/api/oauth/usage"`, { encoding: 'utf-8', timeout: 8000 }).trim();
         if (!raw || raw[0] !== '{')
             return null;
-        const data = JSON.parse(raw);
-        const capturedAt = new Date().toISOString();
-        const apiError = data?.error;
-        if (apiError && typeof apiError === 'object') {
+        return buildClaudeOAuthUsage(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+// Non-blocking variant for the live (getUsageLive) path — execSync would stall the event loop.
+async function fetchClaudeUsageFromOAuth(tokenOverride) {
+    const token = tokenOverride || getClaudeOAuthToken();
+    if (!token)
+        return null;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const res = await fetch('https://api.anthropic.com/api/oauth/usage', {
+            headers: {
+                authorization: `Bearer ${token}`,
+                'anthropic-beta': 'oauth-2025-04-20',
+                'content-type': 'application/json',
+            },
+            signal: controller.signal,
+        });
+        const data = await res.json().catch(() => null);
+        return data ? buildClaudeOAuthUsage(data) : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// Per-account usage for a specific account's `claude setup-token`.
+//
+// IMPORTANT: setup-tokens are minted with the `user:inference` scope only — they do NOT carry
+// `user:profile`, so the read-only OAuth usage endpoint (`/api/oauth/usage`) rejects them with
+// `permission_error … scope requirement user:profile`. The native/default-login token works
+// there because it's a full login. So for account tokens we read the limit state from the
+// `anthropic-ratelimit-unified-*` *response headers* of a tiny inference call instead — those
+// headers come back on every `/v1/messages` response regardless of scope, and are exactly what
+// Claude Code itself uses to learn 5h / 7d limits. Cost is ~1 output token per probe, cached
+// for 5min per token (60s back-off on failure), with in-flight de-dup so concurrent surfaces
+// (cards + header + IM) share one probe.
+const TOKEN_USAGE_OK_TTL_MS = CLAUDE_USAGE_QUERY_TTL_MS;
+const TOKEN_USAGE_RETRY_TTL_MS = 60_000;
+const CLAUDE_USAGE_PROBE_MODEL = 'claude-haiku-4-5-20251001';
+const claudeTokenUsageCache = new Map();
+const claudeTokenUsageInflight = new Map();
+function usageFromRatelimitHeaders(h) {
+    const makeWindow = (label, prefix) => {
+        const raw = h.get(`anthropic-ratelimit-unified-${prefix}-utilization`);
+        if (raw == null || raw === '')
+            return null;
+        const usedPercent = roundPercent(Number(raw) * 100);
+        if (usedPercent == null)
             return null;
+        const remainingPercent = Math.max(0, Math.round((100 - usedPercent) * 10) / 10);
+        const resetAt = toIsoFromEpochSeconds(h.get(`anthropic-ratelimit-unified-${prefix}-reset`));
+        let resetAfterSeconds = null;
+        if (resetAt) {
+            const resetAtMs = Date.parse(resetAt);
+            if (Number.isFinite(resetAtMs))
+                resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
         }
-        const makeWindow = (label, entry) => {
-            if (!entry || typeof entry !== 'object')
-                return null;
-            const usedPercent = roundPercent(entry.utilization);
-            if (usedPercent == null)
-                return null;
-            const remainingPercent = Math.max(0, Math.round((100 - usedPercent) * 10) / 10);
-            const resetAt = typeof entry.resets_at === 'string' ? entry.resets_at : null;
-            let resetAfterSeconds = null;
-            if (resetAt) {
-                const resetAtMs = Date.parse(resetAt);
-                if (Number.isFinite(resetAtMs))
-                    resetAfterSeconds = Math.max(0, Math.round((resetAtMs - Date.now()) / 1000));
-            }
-            return {
-                label, usedPercent, remainingPercent, resetAt, resetAfterSeconds,
-                status: usedPercent >= 100 ? 'limit_reached' : usedPercent >= 80 ? 'warning' : 'allowed',
-            };
+        return {
+            label, usedPercent, remainingPercent, resetAt, resetAfterSeconds,
+            status: usedPercent >= 100 ? 'limit_reached' : usedPercent >= 80 ? 'warning' : 'allowed',
         };
-        const windows = [];
-        for (const [label, key] of [['5h', 'five_hour'], ['7d', 'seven_day'], ['7d Opus', 'seven_day_opus'], ['7d Sonnet', 'seven_day_sonnet'], ['Extra', 'extra_usage']]) {
-            const w = makeWindow(label, data[key]);
-            if (w)
-                windows.push(w);
-        }
-        if (!windows.length)
-            return null;
-        const overallStatus = windows.some(w => w.status === 'limit_reached') ? 'limit_reached'
-            : windows.some(w => w.status === 'warning') ? 'warning' : 'allowed';
-        return { ok: true, agent: 'claude', source: 'oauth-api', capturedAt, status: overallStatus, windows, error: null };
+    };
+    // Only 5h + 7d are real here. The inference headers expose an overage (Extra) on/off STATUS
+    // but never a utilization number, and `/api/oauth/usage` (which returns the actual extra_usage
+    // figure) is scope-blocked for setup-tokens — so we deliberately do NOT synthesize an "Extra"
+    // window for token accounts. Showing a fabricated 0% misrepresents real Extra spend.
+    const windows = [makeWindow('5h', '5h'), makeWindow('7d', '7d')].filter((w) => w != null);
+    if (!windows.length)
+        return null;
+    const overallStatus = windows.some(w => w.status === 'limit_reached') ? 'limit_reached'
+        : windows.some(w => w.status === 'warning') ? 'warning' : 'allowed';
+    return { ok: true, agent: 'claude', source: 'ratelimit-headers', capturedAt: new Date().toISOString(), status: overallStatus, windows, error: null };
+}
+async function claudeUsageFromInferenceHeaders(token) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    try {
+        const res = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${token}`,
+                'anthropic-beta': 'oauth-2025-04-20',
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ model: CLAUDE_USAGE_PROBE_MODEL, max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+            signal: controller.signal,
+        });
+        // The unified rate-limit headers ride on every response (incl. 429), so parse them before
+        // worrying about the status code. Drain the body so the socket can be reused/closed.
+        const usage = usageFromRatelimitHeaders(res.headers);
+        void res.text().catch(() => { });
+        return usage;
     }
     catch {
         return null;
     }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function claudeUsageForToken(token, opts) {
+    const t = String(token || '');
+    if (!t)
+        return Promise.resolve(null);
+    const now = Date.now();
+    const cached = claudeTokenUsageCache.get(t);
+    if (cached && !opts?.force) {
+        const ttl = cached.ok ? TOKEN_USAGE_OK_TTL_MS : TOKEN_USAGE_RETRY_TTL_MS;
+        if (now - cached.at < ttl)
+            return Promise.resolve(cached.value);
+    }
+    const inflight = claudeTokenUsageInflight.get(t);
+    if (inflight)
+        return inflight;
+    const p = (async () => {
+        const fresh = await claudeUsageFromInferenceHeaders(t);
+        const at = Date.now();
+        if (fresh) {
+            claudeTokenUsageCache.set(t, { value: fresh, at, ok: true });
+            return fresh;
+        }
+        // Probe failed (network / transient): keep serving last-good, but back off retries.
+        const value = claudeTokenUsageCache.get(t)?.value ?? null;
+        claudeTokenUsageCache.set(t, { value, at, ok: false });
+        return value;
+    })().finally(() => claudeTokenUsageInflight.delete(t));
+    claudeTokenUsageInflight.set(t, p);
+    return p;
 }
 function getClaudeUsageFromTelemetry(home, model) {
     const telemetryRoot = path.join(home, '.claude', 'telemetry');
@@ -2093,6 +2226,24 @@ class ClaudeDriver {
         }
         return claudeUsageCache.lastGood ?? telemetry();
     }
+    // Live usage for the agent-status surface. Unlike getUsage it ignores the 5-min query TTL and
+    // always re-probes, so a freshly-switched login (the keychain default-login token changed) is
+    // reflected promptly instead of serving the previous account's frozen `lastGood`. Bounded by
+    // the caller's usage timeout, with the cached value as fallback.
+    async getUsageLive(opts) {
+        const home = getHome();
+        if (!home)
+            return emptyUsage('claude', 'HOME is not set.');
+        const fresh = await fetchClaudeUsageFromOAuth();
+        if (fresh) {
+            claudeUsageCache.lastGood = fresh;
+            claudeUsageCache.lastAttemptAt = Date.now();
+            return fresh;
+        }
+        return claudeUsageCache.lastGood
+            ?? getClaudeUsageFromTelemetry(home, opts.model)
+            ?? emptyUsage('claude', 'No recent Claude usage data found.');
+    }
     async deleteNativeSession(workdir, sessionId) {
         const file = claudeSessionTranscriptPath(workdir, sessionId);
         if (!file || !fs.existsSync(file))

package/dist/agent/drivers/codex.js

@@ -1641,6 +1641,11 @@ function getCodexSessionMessagesFromRollout(opts) {
         const fallbackMsgs = [];
         let pendingAssistant = null;
         let sawAssistantResponseItems = false;
+        // Codex records the user turn twice: a rich `response_item` (role=user, carries the image as an
+        // input_image data URL or a localImage path) AND a text-only `event_msg`/user_message. The
+        // user bubble is built from the latter, so stash any images from the former and attach them
+        // when the user_message arrives — otherwise pasted images vanish from codex history on reparse.
+        let pendingUserImages = [];
         const ensureAssistant = () => {
             if (!pendingAssistant)
                 pendingAssistant = { blocks: [], toolNamesByCallId: new Map() };
@@ -1677,12 +1682,18 @@ function getCodexSessionMessagesFromRollout(opts) {
                 if (ev.payload.type === 'user_message' && typeof ev.payload.message === 'string') {
                     flushAssistant();
                     const text = stripInjectedPrompts(ev.payload.message).trim();
-                    if (!text)
+                    const imageBlocks = pendingUserImages;
+                    pendingUserImages = [];
+                    if (!text && !imageBlocks.length)
                         continue;
                     const userMessage = { role: 'user', text };
                     fallbackMsgs.push(userMessage);
                     allMsgs.push(userMessage);
-                    richMsgs.push({ role: 'user', text, blocks: [{ type: 'text', content: text }] });
+                    const blocks = [];
+                    if (text)
+                        blocks.push({ type: 'text', content: text });
+                    blocks.push(...imageBlocks);
+                    richMsgs.push({ role: 'user', text, blocks });
                 }
                 else if (ev.payload.type === 'agent_message' && typeof ev.payload.message === 'string') {
                     const text = ev.payload.message.trim();
@@ -1695,6 +1706,23 @@ function getCodexSessionMessagesFromRollout(opts) {
                 continue;
             const payload = ev.payload;
             if (payload.type === 'message') {
+                if (payload.role === 'user') {
+                    for (const c of (Array.isArray(payload.content) ? payload.content : [])) {
+                        if (c?.type === 'input_image' && typeof c.image_url === 'string' && c.image_url.startsWith('data:image/')) {
+                            pendingUserImages.push({ type: 'image', content: c.image_url });
+                        }
+                        else if (c?.type === 'localImage' && typeof c.path === 'string') {
+                            try {
+                                if (fs.existsSync(c.path) && fs.statSync(c.path).size <= 4 * 1024 * 1024) {
+                                    const ext = path.extname(c.path).toLowerCase();
+                                    pendingUserImages.push({ type: 'image', content: `data:${mimeForExt(ext)};base64,${fs.readFileSync(c.path).toString('base64')}` });
+                                }
+                            }
+                            catch { /* ignore */ }
+                        }
+                    }
+                    continue;
+                }
                 if (payload.role !== 'assistant')
                     continue;
                 const text = extractCodexMessageText(payload.content);

package/dist/agent/kernel-bridge.js

@@ -15,8 +15,44 @@ import { humanizeCodexError } from './drivers/codex.js';
 // Tests always run legacy (the unit suite asserts legacy driver behavior). The bridge
 // re-applies app-level parity the pure kernel must not own (claude jsonl entrypoint, codex humanize).
 const KERNEL_AGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
+// Generic ACP agents the kernel can drive via @pikiloom/kernel's AcpDriver. Hermes is its
+// own built-in preset; this registry is for ANY other ACP CLI (OpenCode, Zed, …). Extend
+// without a code edit via PIKILOOM_ACP_AGENTS='{"zed":{"command":"zed","args":["--acp"]}}'.
+const DEFAULT_ACP_AGENTS = {
+    opencode: { command: 'opencode', args: ['acp'] },
+};
+export function acpAgentConfig(agent) {
+    if (DEFAULT_ACP_AGENTS[agent])
+        return DEFAULT_ACP_AGENTS[agent];
+    try {
+        const extra = process.env.PIKILOOM_ACP_AGENTS ? JSON.parse(process.env.PIKILOOM_ACP_AGENTS) : null;
+        const c = extra?.[agent];
+        if (c && (c.command || agent))
+            return { command: String(c.command || agent), args: Array.isArray(c.args) ? c.args.map(String) : ['acp'] };
+    }
+    catch { /* malformed env → ignore */ }
+    return null;
+}
+// pikiloom's mcpServers (Record) -> kernel McpServerSpec[] for ACP session/new forwarding.
+function mcpRecordToKernelSpecs(servers) {
+    if (!servers)
+        return [];
+    const out = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+        if (!cfg || typeof cfg !== 'object')
+            continue;
+        const type = String(cfg.type || '').toLowerCase();
+        if ((type === 'http' || type === 'sse') && cfg.url) {
+            out.push({ name, type: 'http', url: String(cfg.url), headers: cfg.headers || {} });
+            continue;
+        }
+        if (cfg.command)
+            out.push({ name, type: 'stdio', command: String(cfg.command), args: Array.isArray(cfg.args) ? cfg.args.map(String) : [], env: cfg.env || {} });
+    }
+    return out;
+}
 export function shouldUseKernelPipeline(agent) {
-    if (!KERNEL_AGENTS.has(agent))
+    if (!KERNEL_AGENTS.has(agent) && !acpAgentConfig(agent))
         return false;
     if (process.env.VITEST || process.env.NODE_ENV === 'test')
         return false; // tests assert legacy
@@ -41,7 +77,15 @@ function buildKernelDriver(kernel, opts) {
         effort: opts.thinkingEffort,
         env: opts.extraEnv,
         mcpConfigPath: opts.mcpConfigPath ?? null,
+        // Consumed by the ACP path (Hermes + generic AcpDriver) for session/new forwarding;
+        // ignored by claude/codex/gemini (they carry MCP via config file / native registration).
+        extraMcpServers: mcpRecordToKernelSpecs(opts.mcpServers),
     };
+    // Any registered generic ACP agent (OpenCode, …) -> the kernel's AcpDriver.
+    const acp = acpAgentConfig(opts.agent);
+    if (acp) {
+        return { driver: new kernel.AcpDriver({ id: opts.agent, command: acp.command, args: acp.args }), input: { ...common, model: opts.model ?? null } };
+    }
     switch (opts.agent) {
         case 'codex': {
             // codexExtraArgs is a flattened ['-c','k=v','-c','k=v',...]; extract the k=v values
@@ -65,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)
@@ -141,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 */ }
     };
@@ -185,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/agent/session.js

@@ -184,6 +184,7 @@ function normalizeSessionRecord(raw, workdir) {
         thinkingEffort: typeof raw?.thinkingEffort === 'string' && raw.thinkingEffort.trim() ? raw.thinkingEffort.trim() : null,
         workflowEnabled: typeof raw?.workflowEnabled === 'boolean' ? raw.workflowEnabled : null,
         profileId: typeof raw?.profileId === 'string' && raw.profileId.trim() ? raw.profileId.trim() : null,
+        accountId: typeof raw?.accountId === 'string' && raw.accountId.trim() ? raw.accountId.trim() : null,
         stagedFiles: Array.isArray(raw?.stagedFiles) ? dedupeStrings(raw.stagedFiles.filter((v) => typeof v === 'string')) : [],
         lastUserAttachments: Array.isArray(raw?.lastUserAttachments)
             ? dedupeStrings(raw.lastUserAttachments.filter((v) => typeof v === 'string'))
@@ -327,7 +328,7 @@ function writeSessionMeta(record) {
         workspacePath: record.workspacePath,
         threadId: record.threadId,
         createdAt: record.createdAt, updatedAt: record.updatedAt,
-        title: record.title, model: record.model, thinkingEffort: record.thinkingEffort, workflowEnabled: record.workflowEnabled, profileId: record.profileId, stagedFiles: record.stagedFiles,
+        title: record.title, model: record.model, thinkingEffort: record.thinkingEffort, workflowEnabled: record.workflowEnabled, profileId: record.profileId, accountId: record.accountId ?? null, stagedFiles: record.stagedFiles,
         runState: record.runState, runDetail: record.runDetail, runUpdatedAt: record.runUpdatedAt,
         runPid: record.runPid,
         classification: record.classification,
@@ -563,7 +564,7 @@ export function ensureSessionWorkspace(opts) {
             workspacePath: sessionWorkspacePath(workdir, opts.agent, sessionId),
             threadId,
             createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
-            title: summarizePromptTitle(opts.title) || null, model: null, thinkingEffort: null, workflowEnabled: null, profileId: null, stagedFiles: [], lastUserAttachments: [],
+            title: summarizePromptTitle(opts.title) || null, model: null, thinkingEffort: null, workflowEnabled: null, profileId: null, accountId: null, stagedFiles: [], lastUserAttachments: [],
             runState: 'completed', runDetail: null, runUpdatedAt: new Date().toISOString(),
             runPid: null,
             classification: null, userStatus: null, userNote: null,
@@ -597,6 +598,7 @@ export function managedRecordToSessionInfo(record) {
         thinkingEffort: record.thinkingEffort,
         workflowEnabled: record.workflowEnabled ?? null,
         profileId: record.profileId ?? null,
+        accountId: record.accountId ?? null,
         createdAt: record.createdAt,
         title,
         running: record.runState === 'running',
@@ -680,6 +682,7 @@ export function getSessionStoredConfig(workdir, agent, sessionId) {
         thinkingEffort: record?.thinkingEffort ?? null,
         workflowEnabled: record?.workflowEnabled ?? null,
         profileId: record?.profileId ?? null,
+        accountId: record?.accountId ?? null,
     };
 }
 export function ensureManagedSession(opts) {
@@ -774,6 +777,7 @@ export function mergeManagedAndNativeSessions(managedSessions, nativeSessions) {
             thinkingEffort: managed.thinkingEffort ?? native.thinkingEffort ?? null,
             workflowEnabled: managed.workflowEnabled ?? native.workflowEnabled ?? null,
             profileId: managed.profileId ?? native.profileId ?? null,
+            accountId: managed.accountId ?? native.accountId ?? null,
             createdAt: native.createdAt || managed.createdAt,
             classification: managed.classification ?? native.classification ?? null,
             userStatus: managed.userStatus ?? native.userStatus ?? null,

package/dist/agent/stream.js

@@ -13,6 +13,7 @@ import { saveSessionRecord, setSessionRunState, applySessionRunResult, ensureSes
 import { clearAwaitResume } from './await-resume.js';
 import { collapseSkillPrompt } from './skills.js';
 import { shouldUseKernelPipeline, kernelStream } from './kernel-bridge.js';
+import { accountAgentSupported, resolveAccountEnv, updateAccount } from './accounts.js';
 function trimSessionText(value, max = 24_000) {
     const text = typeof value === 'string' ? value.trim() : '';
     if (!text)
@@ -531,6 +532,29 @@ export async function doStream(opts) {
     catch (e) {
         agentWarn(`[byok] failed to apply Profile injection: ${e?.message || e}`);
     }
+    // Multi-account (native subscription): when NO BYOK profile is bound, route the turn
+    // through the agent's active local account by injecting its isolated config dir
+    // (CLAUDE_CONFIG_DIR / CODEX_HOME). A BYOK profile owns the credential, so it takes over
+    // and account injection is skipped — the two axes are mutually exclusive per turn.
+    try {
+        if (accountAgentSupported(prepared.agent)) {
+            const profileBound = prepared.profileId === undefined
+                ? !!getActiveProfile(prepared.agent)
+                : !!(prepared.profileId && getProfile(prepared.profileId));
+            if (!profileBound) {
+                const resolved = await resolveAccountEnv(prepared.agent, prepared.accountId);
+                if (resolved) {
+                    prepared.extraEnv = { ...(prepared.extraEnv || {}), ...resolved.env };
+                    prepared.accountId = resolved.accountId;
+                    agentLog(`[account] ${prepared.agent} turn → account=${resolved.accountId} (${Object.keys(resolved.env).join('+')})`);
+                    void updateAccount(prepared.agent, resolved.accountId, { lastUsedAt: new Date().toISOString() }).catch(() => { });
+                }
+            }
+        }
+    }
+    catch (e) {
+        agentWarn(`[account] injection failed: ${e?.message || e}`);
+    }
     try {
         if (prepared.thinkingEffort) {
             session.record.thinkingEffort = prepared.thinkingEffort.trim().toLowerCase() || session.record.thinkingEffort;
@@ -548,6 +572,8 @@ export async function doStream(opts) {
             session.record.model = turnModel;
         if (prepared.profileId !== undefined)
             session.record.profileId = prepared.profileId || null;
+        if (prepared.accountId !== undefined)
+            session.record.accountId = prepared.accountId || null;
         saveSessionRecord(opts.workdir, session.record);
     }
     catch (e) {

package/dist/bot/bot.js

@@ -2,7 +2,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { getActiveUserConfig, loadWorkspaces, onUserConfigChange, resolveUserWorkdir, setUserWorkdir, updateUserConfig } from '../core/config/user-config.js';
-import { doStream, ensureManagedSession, findManagedThreadSession, getSessionStoredConfig, getUsage, initializeProjectSkills, listAgents, resolveAgentModels, resolveDefaultAgent, listSkills, stageSessionFiles, reconcileOrphanedRunningSessions, getAgentBoundModelId, setAgentBoundModelId, collapseSkillPrompt, readGoal, accountTurn, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, bumpContinuationCount, pauseGoal, resumeGoal, setGoal as setGoalState, clearGoal as clearGoalState, setCodexGoal, getCodexGoal, clearCodexGoal, pauseCodexGoal, resumeCodexGoal, getClaudeNativeGoal, buildClaudeSetGoalPrompt, buildClaudeClearGoalPrompt, deliverArtifact, attachmentUrl, isPendingSessionId, } from '../agent/index.js';
+import { doStream, ensureManagedSession, findManagedThreadSession, getSessionStoredConfig, getUsage, initializeProjectSkills, listAgents, resolveAgentModels, resolveDefaultAgent, listSkills, stageSessionFiles, reconcileOrphanedRunningSessions, getAgentBoundModelId, setAgentBoundModelId, collapseSkillPrompt, readGoal, accountTurn, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, bumpContinuationCount, pauseGoal, resumeGoal, setGoal as setGoalState, clearGoal as clearGoalState, setCodexGoal, getCodexGoal, clearCodexGoal, pauseCodexGoal, resumeCodexGoal, getClaudeNativeGoal, buildClaudeSetGoalPrompt, buildClaudeClearGoalPrompt, deliverArtifact, attachmentUrl, attachAgentImage, rewriteAttachmentBlocksForTransport, isPendingSessionId, } from '../agent/index.js';
 import { compactForHandover, describeHandoverRef } from '../agent/handover.js';
 import { getActiveProfileId, getActiveProfile, setActiveProfile } from '../model/index.js';
 import { querySessions, querySessionTail, updateSession, } from './session-hub.js';
@@ -160,16 +160,48 @@ export class Bot {
         const snap = this.streamSnapshots.get(this.resolveSessionKey(sessionKey));
         return snap ? this.enrichSnapshot(snap) : null;
     }
+    taskAttachmentBlocks(task) {
+        if (!task?.attachments?.length)
+            return [];
+        const session = this.getSessionRuntimeByKey(task.sessionKey, { allowAnyWorkdir: true });
+        const sessionId = session?.sessionId || task.sessionKey.slice(task.agent.length + 1);
+        if (!sessionId)
+            return [];
+        const blocks = task.attachments
+            .map(imagePath => attachAgentImage({ imagePath, inlineThresholdBytes: 0 }))
+            .filter((block) => !!block);
+        return blocks.length
+            ? rewriteAttachmentBlocksForTransport(blocks, { agent: task.agent, sessionId })
+            : [];
+    }
+    taskPreview(taskId) {
+        const task = this.activeTasks.get(taskId) || null;
+        const raw = task?.prompt || '';
+        const attachments = this.taskAttachmentBlocks(task);
+        return {
+            taskId,
+            prompt: collapseSkillPrompt(raw) ?? raw,
+            ...(attachments.length ? { attachments } : {}),
+        };
+    }
     enrichSnapshot(snap) {
         let next = snap;
-        const runningPrompt = next.taskId ? this.activeTasks.get(next.taskId)?.prompt : '';
-        if (runningPrompt)
-            next = { ...next, question: collapseSkillPrompt(runningPrompt) ?? runningPrompt };
-        if (next.queuedTaskIds?.length) {
-            const queuedTasks = next.queuedTaskIds.map(taskId => {
-                const raw = this.activeTasks.get(taskId)?.prompt || '';
-                return { taskId, prompt: collapseSkillPrompt(raw) ?? raw };
-            });
+        const runningTask = next.taskId ? this.activeTasks.get(next.taskId) : null;
+        const runningPrompt = runningTask?.prompt || '';
+        if (runningPrompt) {
+            const questionBlocks = this.taskAttachmentBlocks(runningTask);
+            next = {
+                ...next,
+                question: collapseSkillPrompt(runningPrompt) ?? runningPrompt,
+                ...(questionBlocks.length ? { questionBlocks } : {}),
+            };
+        }
+        const queuedIds = [
+            ...(next.phase === 'queued' && next.taskId ? [next.taskId] : []),
+            ...(next.queuedTaskIds || []),
+        ].filter((taskId, index, all) => taskId && all.indexOf(taskId) === index);
+        if (queuedIds.length) {
+            const queuedTasks = queuedIds.map(taskId => this.taskPreview(taskId));
             next = { ...next, queuedTasks };
         }
         if (next.interactions?.length) {
@@ -234,13 +266,16 @@ export class Bot {
         switch (event.type) {
             case 'queued': {
                 const existing = this.streamSnapshots.get(sessionKey);
-                if (existing && (existing.phase === 'streaming' || existing.phase === 'done')) {
+                if (existing && existing.phase === 'streaming') {
                     const list = existing.queuedTaskIds ? [...existing.queuedTaskIds] : [];
                     if (existing.taskId !== event.taskId && !list.includes(event.taskId))
                         list.push(event.taskId);
                     existing.queuedTaskIds = list.length ? list : undefined;
                     existing.updatedAt = now;
                 }
+                else if (existing && existing.phase === 'done') {
+                    this.streamSnapshots.set(sessionKey, { phase: 'queued', taskId: event.taskId, updatedAt: now });
+                }
                 else if (existing && existing.phase === 'queued') {
                     const list = existing.queuedTaskIds ? [...existing.queuedTaskIds] : [];
                     if (existing.taskId !== event.taskId && !list.includes(event.taskId))