pikiloom 0.4.16 → 0.4.17

package/dist/agent/artifacts.js

@@ -0,0 +1,160 @@
+/**
+ * artifacts.ts — delivered-artifact manifest (the single source of truth for
+ * "files the agent handed to the user during a session").
+ *
+ * When the agent calls `im_send_file`, the bot materializes the file into the
+ * session attachments dir and appends a record here. IM channels additionally
+ * push the bytes to their chat; the dashboard serves the materialized copy over
+ * HTTP and renders it. Recording is terminal-agnostic, so a session watched
+ * from BOTH a chat and the dashboard shows the same deliveries on either side,
+ * and they survive a page reload / workspace cleanup.
+ *
+ * The manifest lives next to the MCP-buffered image attachments
+ * (`sessionAttachmentsDir`), which is already an allowlist root for the
+ * dashboard attachment endpoint — so materialized artifacts are servable with
+ * no new trust boundary.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { sessionAttachmentsDir } from './images.js';
+import { agentWarn } from './utils.js';
+const PHOTO_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg']);
+const MIME_BY_EXT = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.webp': 'image/webp', '.svg': 'image/svg+xml',
+    '.pdf': 'application/pdf', '.txt': 'text/plain; charset=utf-8', '.md': 'text/markdown; charset=utf-8',
+    '.csv': 'text/csv; charset=utf-8', '.json': 'application/json', '.xml': 'application/xml',
+    '.html': 'text/html; charset=utf-8', '.zip': 'application/zip', '.gz': 'application/gzip',
+    '.tar': 'application/x-tar', '.mp4': 'video/mp4', '.mov': 'video/quicktime', '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.log': 'text/plain; charset=utf-8',
+};
+/** Best-effort MIME for a delivered artifact; `application/octet-stream` when unknown. */
+export function mimeForArtifact(filePath) {
+    return MIME_BY_EXT[path.extname(filePath).toLowerCase()] || 'application/octet-stream';
+}
+function manifestPath(agent, sessionId) {
+    return path.join(sessionAttachmentsDir(agent, sessionId), 'delivered.jsonl');
+}
+function deliveredDir(agent, sessionId) {
+    return path.join(sessionAttachmentsDir(agent, sessionId), 'delivered');
+}
+function sanitizeName(name) {
+    return (name || 'file').replace(/[/\\\0]+/g, '_').replace(/^\.+/, '').slice(0, 200) || 'file';
+}
+/**
+ * Materialize `srcPath` into the session's delivered-artifacts dir so it is
+ * (a) servable by the dashboard attachment endpoint (the dir is an allowlist
+ * root) and (b) durable across workspace cleanup. Hardlinks when possible,
+ * falling back to a copy across filesystems. The on-disk name is stamped to
+ * avoid collisions; the pristine basename travels in the manifest.
+ */
+export function stageDeliveredArtifact(agent, sessionId, srcPath) {
+    const fileName = sanitizeName(path.basename(srcPath));
+    const stat = fs.statSync(srcPath);
+    const dir = deliveredDir(agent, sessionId);
+    fs.mkdirSync(dir, { recursive: true });
+    const stamp = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+    const dest = path.join(dir, `${stamp}-${fileName}`);
+    try {
+        fs.linkSync(srcPath, dest);
+    }
+    catch {
+        fs.copyFileSync(srcPath, dest);
+    }
+    return { path: dest, fileName, fileSize: stat.size, fileMime: mimeForArtifact(fileName) };
+}
+/** Append a record to the session's delivered-artifact manifest. */
+export function recordDeliveredArtifact(agent, sessionId, entry) {
+    try {
+        const file = manifestPath(agent, sessionId);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, JSON.stringify(entry) + '\n');
+    }
+    catch (e) {
+        agentWarn(`[artifacts] record failed: ${e?.message || e}`);
+    }
+}
+/**
+ * Materialize + record a delivered artifact in one step. Best-effort: returns
+ * the stored record (with the materialized path), or null on failure — delivery
+ * must never crash the stream.
+ */
+export function deliverArtifact(agent, sessionId, srcPath, opts) {
+    try {
+        const staged = stageDeliveredArtifact(agent, sessionId, srcPath);
+        const record = {
+            ts: Date.now(),
+            ...(opts.taskId ? { taskId: opts.taskId } : {}),
+            path: staged.path,
+            fileName: staged.fileName,
+            fileMime: staged.fileMime,
+            fileSize: staged.fileSize,
+            kind: opts.kind,
+            ...(opts.caption ? { caption: opts.caption } : {}),
+        };
+        recordDeliveredArtifact(agent, sessionId, record);
+        return record;
+    }
+    catch (e) {
+        agentWarn(`[artifacts] deliver failed for ${srcPath}: ${e?.message || e}`);
+        return null;
+    }
+}
+/** Read the delivered-artifact manifest for a session (tolerant of partial lines). */
+export function readDeliveredArtifacts(agent, sessionId) {
+    const file = manifestPath(agent, sessionId);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const rec = JSON.parse(t);
+            if (rec && typeof rec.path === 'string' && rec.fileName)
+                out.push(rec);
+        }
+        catch { /* skip malformed line */ }
+    }
+    return out;
+}
+/**
+ * Project the delivered-artifact manifest into pre-transport MessageBlocks
+ * (content = `file://<abs>`). The dashboard read path rewrites these to
+ * attachment HTTP URLs via `rewriteAttachmentBlocksForTransport`. Records whose
+ * file no longer exists on disk are dropped.
+ */
+export function deliveredArtifactBlocks(agent, sessionId) {
+    const blocks = [];
+    for (const a of readDeliveredArtifacts(agent, sessionId)) {
+        if (!fs.existsSync(a.path))
+            continue;
+        if (a.kind === 'photo' && PHOTO_EXTS.has(path.extname(a.fileName).toLowerCase())) {
+            blocks.push({
+                type: 'image',
+                content: `file://${a.path}`,
+                imagePath: a.path,
+                imageMime: a.fileMime,
+                ...(a.caption ? { imageCaption: a.caption } : {}),
+            });
+        }
+        else {
+            blocks.push({
+                type: 'file',
+                content: `file://${a.path}`,
+                filePath: a.path,
+                fileMime: a.fileMime,
+                fileName: a.fileName,
+                fileSize: a.fileSize,
+                ...(a.caption ? { fileCaption: a.caption } : {}),
+            });
+        }
+    }
+    return blocks;
+}

package/dist/agent/images.js

@@ -1,10 +1,13 @@
 /**
- * images.ts — unified image pipeline for the agent layer.
+ * images.ts — unified image (and on-disk attachment) pipeline for the agent
+ * layer.
  *
  * Every driver produces image blocks through `attachAgentImage`, every IM
  * channel consumes them through `materializeImage`, and every dashboard
- * response routes large images through the attachment HTTP endpoint via
- * `rewriteImageBlocksForTransport`. The shape isolates *where the bytes live*
+ * response routes on-disk image/file blocks through the attachment HTTP
+ * endpoint via `rewriteAttachmentBlocksForTransport` (delivered non-image files
+ * — see agent/artifacts.ts — ride the same transport). The shape isolates
+ * *where the bytes live*
  * from *how a renderer wants to consume them*, so adding a new driver source
  * (Codex `image_generation_call`, Claude MCP `tool_result` image, Gemini Imagen,
  * future) or a new transport (a fourth IM channel, a CLI exporter, an OG-image
@@ -25,7 +28,7 @@
  *  - `content` always carries a directly-renderable reference: a `data:` URL
  *    for inline bytes, or an attachment HTTP URL for files on disk.
  *  - Below `INLINE_THRESHOLD_BYTES`, drivers may inline as `data:`. Above the
- *    threshold, `rewriteImageBlocksForTransport` substitutes a relative
+ *    threshold, `rewriteAttachmentBlocksForTransport` substitutes a relative
  *    `/api/sessions/:agent/:id/attachment?...` URL — keeps RichMessage
  *    payloads small even when a session has many large images.
  *  - IM channels prefer `imagePath` over decoding `content`, avoiding wasted
@@ -192,7 +195,7 @@ export function attachAgentImage(opts) {
     }
     else {
         // Sentinel: the transport layer rewrites this into an HTTP URL with the
-        // right session context. Renderers that bypass `rewriteImageBlocksForTransport`
+        // right session context. Renderers that bypass `rewriteAttachmentBlocksForTransport`
         // see a `file://` URL and can still resolve it via `materializeImage` since
         // `imagePath` is also populated.
         content = `file://${abs}`;
@@ -321,29 +324,53 @@ export function decodeAttachmentPathParam(value) {
     return Buffer.from(normalized, 'base64').toString('utf-8');
 }
 /**
- * Rewrite a block array for transport: any image block whose `content` is a
- * `file://` sentinel becomes an attachment HTTP URL, and any inline `data:`
- * URL above the threshold is also promoted to an HTTP URL (keeping the
- * RichMessage payload compact even when a session has many large images).
+ * Build the dashboard attachment URL that serves `absPath` for a given session.
+ * Single source for the `/api/sessions/:agent/:id/attachment?p=…` shape so the
+ * transport rewrite, live stream snapshots, and any future caller stay in sync.
+ * `downloadName` is carried as an opaque `&n=` hint the endpoint uses for the
+ * Content-Disposition filename (the pristine basename, not the on-disk one).
+ */
+export function attachmentUrl(agent, sessionId, absPath, opts = {}) {
+    const base = (opts.apiBase || '/api/sessions').replace(/\/+$/, '');
+    const encoded = encodePathForUrl(absPath);
+    const name = opts.downloadName ? `&n=${encodeURIComponent(opts.downloadName)}` : '';
+    return `${base}/${encodeURIComponent(agent)}/${encodeURIComponent(sessionId)}/attachment?p=${encoded}${name}`;
+}
+/**
+ * Rewrite a block array for transport. Image and file blocks whose `content`
+ * is a `file://` sentinel (or which carry an on-disk `imagePath`/`filePath`)
+ * become attachment HTTP URLs; inline `data:` image URLs are left untouched so
+ * the dashboard renders them directly. Keeps RichMessage payloads compact even
+ * when a session delivered many large artifacts.
  *
  * Pure: returns a new array; the input is not mutated.
  */
-export function rewriteImageBlocksForTransport(blocks, ctx) {
-    const base = (ctx.apiBase || '/api/sessions').replace(/\/+$/, '');
+export function rewriteAttachmentBlocksForTransport(blocks, ctx) {
     return blocks.map(block => {
-        if (block.type !== 'image')
-            return block;
-        const sourcePath = block.imagePath
-            || (block.content?.startsWith('file://') ? block.content.slice('file://'.length) : '');
-        if (!sourcePath)
-            return block;
-        // Inline content under the threshold: leave the data URL alone — the
-        // dashboard renders it directly, no extra request.
-        if (block.content?.startsWith('data:'))
-            return block;
-        const encoded = encodePathForUrl(sourcePath);
-        const url = `${base}/${encodeURIComponent(ctx.agent)}/${encodeURIComponent(ctx.sessionId)}/attachment?p=${encoded}`;
-        return { ...block, content: url, imagePath: sourcePath };
+        if (block.type === 'image') {
+            const sourcePath = block.imagePath
+                || (block.content?.startsWith('file://') ? block.content.slice('file://'.length) : '');
+            if (!sourcePath)
+                return block;
+            // Inline content under the threshold: leave the data URL alone — the
+            // dashboard renders it directly, no extra request.
+            if (block.content?.startsWith('data:'))
+                return block;
+            const url = attachmentUrl(ctx.agent, ctx.sessionId, sourcePath, { apiBase: ctx.apiBase });
+            return { ...block, content: url, imagePath: sourcePath };
+        }
+        if (block.type === 'file') {
+            const sourcePath = block.filePath
+                || (block.content?.startsWith('file://') ? block.content.slice('file://'.length) : '');
+            if (!sourcePath)
+                return block;
+            const url = attachmentUrl(ctx.agent, ctx.sessionId, sourcePath, {
+                apiBase: ctx.apiBase,
+                downloadName: block.fileName || undefined,
+            });
+            return { ...block, content: url, filePath: sourcePath };
+        }
+        return block;
     });
 }
 // ---------------------------------------------------------------------------

package/dist/agent/index.js

@@ -18,8 +18,10 @@ import './drivers/codex.js';
 import './drivers/gemini.js';
 import './drivers/hermes.js';
 export { IMAGE_EXTS } from './types.js';
-// ── Re-export: image pipeline ──────────────────────────────────────────────
-export { attachAgentImage, attachInlineImage, materializeImage, rewriteImageBlocksForTransport, resolveAllowedAttachmentPath, allowedAttachmentRoots, decodeAttachmentPathParam, sessionAttachmentsDir, codexHome, } from './images.js';
+// ── Re-export: attachment pipeline (images + delivered files) ───────────────
+export { attachAgentImage, attachInlineImage, materializeImage, rewriteAttachmentBlocksForTransport, attachmentUrl, resolveAllowedAttachmentPath, allowedAttachmentRoots, decodeAttachmentPathParam, sessionAttachmentsDir, codexHome, } from './images.js';
+// ── Re-export: delivered-artifact manifest ──────────────────────────────────
+export { deliverArtifact, readDeliveredArtifacts, deliveredArtifactBlocks, mimeForArtifact, } from './artifacts.js';
 // ── Re-export: utilities ────────────────────────────────────────────────────
 export { Q, agentLog, agentWarn, agentError, dedupeStrings, numberOrNull, normalizeStreamPreviewPlan, parseTodoWriteAsPlan, normalizeActivityLine, pushRecentActivity, detectClaudeApiError, isRetryableClaudeApiError, detectClaudeModelError, claudeModelErrorMessage, firstNonEmptyLine, shortValue, normalizeErrorMessage, joinErrorMessages, appendSystemPrompt, mimeForExt, computeContext, buildStreamPreviewMeta, summarizeClaudeToolUse, summarizeClaudeToolResult, previewToolCallInput, previewToolCallResult, roundPercent, toIsoFromEpochSeconds, normalizeUsageStatus, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, modelFamily, normalizeClaudeModelId, emptyUsage, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, stripClaudeAtMentionImages, isPendingSessionId, emitSessionIdUpdate, sessionListDisplayTitle, } from './utils.js';
 // ── Re-export: session management ───────────────────────────────────────────

package/dist/agent/mcp/tools/workspace.js

@@ -1,8 +1,9 @@
 /**
  * tools/workspace.ts — Workspace file tools.
  *
- *   workspace_list_files — returns workspace path, staged files, and directory listing
- *   workspace_send_file  — sends a file back to the IM chat
+ *   im_list_files — returns workspace path, staged files, and directory listing
+ *   im_send_file  — delivers a file to the user via the active terminal
+ *                   (IM chat push and/or the dashboard attachment endpoint)
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -28,7 +29,7 @@ const tools = [
     },
     {
         name: 'im_send_file',
-        description: 'Send a file to the user in IM.',
+        description: 'Send a file to the user through the active terminal (IM chat or web dashboard). Use this to hand over screenshots, reports, archives, or generated assets — the file is delivered and stays retrievable even when the user is connected remotely. Prefer this over printing a local filesystem path, which a remote user cannot open.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/bot/bot.js

@@ -7,7 +7,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, 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, isPendingSessionId, } from '../agent/index.js';
 import { compactForHandover, describeHandoverRef } from '../agent/handover.js';
 import { getActiveProfileId, setActiveProfile } from '../model/index.js';
 import { querySessions, querySessionTail, updateSession, } from './session-hub.js';
@@ -58,10 +58,14 @@ function appendExtraPrompt(base, extra) {
         return lhs;
     return `${lhs}\n\n${rhs}`;
 }
+// NOTE: the `[Artifact Return]` header is a load-bearing marker — both
+// `stripInjectedPrompts` (bot/streaming.ts) and Gemini's
+// `GEMINI_SYSTEM_BLOCK_SENTINELS` key on it to strip this injected block from
+// displayed user messages. Keep the token in sync if you ever change it.
 function buildMcpDeliveryPrompt() {
     return [
         '[Artifact Return]',
-        'This is an IM/chat conversation, so pay attention to the IM tools.',
+        'To hand a file to the user — a screenshot, report, archive, generated asset, anything they asked you to "send" — call the `im_send_file` tool with the file path and a short caption. It is delivered through whatever terminal the user is on (an IM chat or the web dashboard) and stays retrievable even when they are connected remotely. Do NOT just print a local filesystem path: a remote user cannot open paths on this machine.',
     ].join('\n');
 }
 function buildClaudeAskUserPrompt() {
@@ -360,6 +364,14 @@ export class Bot {
                 }
                 break;
             }
+            case 'artifact': {
+                const snap = this.streamSnapshots.get(sessionKey);
+                if (snap) {
+                    snap.artifacts = [...(snap.artifacts || []), event.artifact];
+                    snap.updatedAt = now;
+                }
+                break;
+            }
             case 'done': {
                 const prev = this.streamSnapshots.get(sessionKey);
                 this.streamSnapshots.set(sessionKey, {
@@ -375,6 +387,7 @@ export class Bot {
                     model: prev?.model ?? null,
                     effort: prev?.effort ?? null,
                     previewMeta: prev?.previewMeta ?? null,
+                    artifacts: prev?.artifacts,
                     startedAt: prev?.startedAt,
                     queuedTaskIds: prev?.queuedTaskIds,
                     updatedAt: now,
@@ -482,6 +495,58 @@ export class Bot {
     emitStreamCancelled(taskId, fallbackKey) {
         this.emitStream(this.liveSessionKey(taskId, fallbackKey), { type: 'cancelled', taskId });
     }
+    /**
+     * Wrap a per-turn `im_send_file` callback so every artifact delivery is
+     * recorded to the session's durable manifest (agent/artifacts.ts) and
+     * mirrored live into the running turn's snapshot — on top of whatever
+     * terminal-specific push the caller supplied (`inner`, e.g. an IM chat
+     * upload). The returned callback is always safe to register, so the tool is
+     * available for dashboard / headless turns that have no `inner` (the
+     * dashboard serves the recorded copy over HTTP). Recording is best-effort and
+     * never propagates an error back into the delivery result.
+     */
+    buildArtifactSendFile(agent, sessionKey, cs, inner) {
+        return async (filePath, sendOpts) => {
+            // Terminal-specific push first (IM chat). Dashboard / headless has no inner.
+            const result = inner ? await inner(filePath, sendOpts) : { ok: true };
+            if (!result.ok)
+                return result;
+            try {
+                // Resolve the freshest session id at delivery time — send_file fires
+                // late in a turn, after a pending→native promotion has normally already
+                // happened, so the manifest lands under the canonical id.
+                let sid = '';
+                if (sessionKey) {
+                    const rt = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
+                    if (rt?.sessionId)
+                        sid = rt.sessionId;
+                }
+                if (!sid && typeof cs.sessionId === 'string')
+                    sid = cs.sessionId;
+                if (!sid || isPendingSessionId(sid))
+                    return result;
+                const kind = sendOpts?.kind === 'photo' ? 'photo' : 'document';
+                const record = deliverArtifact(agent, sid, filePath, { kind, caption: sendOpts?.caption });
+                if (record && sessionKey) {
+                    this.emitStream(this.resolveSessionKey(sessionKey), {
+                        type: 'artifact',
+                        artifact: {
+                            url: attachmentUrl(agent, sid, record.path, { downloadName: record.fileName }),
+                            fileName: record.fileName,
+                            fileSize: record.fileSize,
+                            mime: record.fileMime,
+                            kind: record.kind,
+                            ...(record.caption ? { caption: record.caption } : {}),
+                        },
+                    });
+                }
+            }
+            catch (e) {
+                this.warn(`[runStream] artifact record failed: ${e?.message || e}`);
+            }
+            return result;
+        };
+    }
     keepAliveProc = null;
     keepAlivePulseTimer = null;
     sessionChains = new Map();
@@ -2376,7 +2441,21 @@ export class Bot {
         // falls back to the agent's in-memory flag (IM /mode) when unspecified.
         // Default off — never read from a persisted config default.
         const workflowEnabled = cs.agent === 'claude' && (extras?.workflowEnabled ?? this.claudeWorkflowEnabled);
-        const mcpSystemPrompt = appendExtraPrompt(appendExtraPrompt(appendExtraPrompt(mcpSendFile ? buildMcpDeliveryPrompt() : '', onInteraction && cs.agent === 'claude' ? buildClaudeAskUserPrompt() : ''), buildBrowserAutomationPrompt(browserEnabled)), workflowEnabled ? buildWorkflowOptInPrompt() : '');
+        // ── Artifact delivery (terminal-agnostic) ──
+        // `im_send_file` is the single "hand a file to the user" verb. Whatever the
+        // caller wired as `mcpSendFile` (an IM channel push, or nothing for a
+        // dashboard / headless turn) is wrapped so every delivery ALSO records the
+        // file into the session's delivered-artifact manifest — the durable SSOT
+        // that survives reload + workspace cleanup and is servable over HTTP — and
+        // surfaces it live in the running turn's snapshot for any watching
+        // dashboard. Always provided, so the tool + delivery prompt light up even
+        // when there is no IM channel (the dashboard is the delivery surface then).
+        const deliverySessionKey = ('key' in cs && typeof cs.key === 'string') ? cs.key : null;
+        const wrappedSendFile = this.buildArtifactSendFile(cs.agent, deliverySessionKey, cs, mcpSendFile);
+        const mcpSystemPrompt = appendExtraPrompt(appendExtraPrompt(appendExtraPrompt(
+        // Always-on: `wrappedSendFile` is provided for every turn (see above),
+        // so artifact delivery is available regardless of terminal.
+        buildMcpDeliveryPrompt(), onInteraction && cs.agent === 'claude' ? buildClaudeAskUserPrompt() : ''), buildBrowserAutomationPrompt(browserEnabled)), workflowEnabled ? buildWorkflowOptInPrompt() : '');
         // mcpSystemPrompt carries behaviour directives (use im_ask_user instead of
         // built-in AskUserQuestion, browser automation status, artifact delivery)
         // that must apply on every turn, not just the first — on resume the CLI
@@ -2433,7 +2512,7 @@ export class Bot {
             // a Profile is bound).
             hermesModel: cs.agent === 'hermes' && resolvedModel ? resolvedModel : undefined,
             // MCP bridge
-            mcpSendFile,
+            mcpSendFile: wrappedSendFile,
             abortSignal,
             onInteraction,
             onSteerReady,

package/dist/bot/commands.js

@@ -247,6 +247,52 @@ export async function getSessionsPageData(bot, chatId, page, pageSize = 5) {
         sessions: entries,
     };
 }
+export async function getSessionsDigestData(bot, chatId, limit = 8) {
+    const pageData = await getSessionsPageData(bot, chatId, 0, Math.max(1, limit));
+    const entries = pageData.sessions.map((session, index) => ({
+        index: index + 1,
+        agent: session.agent,
+        title: session.title,
+        time: session.time,
+        runState: session.runState,
+        runDetail: session.runDetail,
+        isCurrent: session.isCurrent,
+        sessionKey: session.key,
+    }));
+    return {
+        workspaceName: pageData.workspaceName,
+        agentTotals: pageData.agentTotals,
+        total: pageData.total,
+        entries,
+    };
+}
+export function formatSessionsDigestText(data) {
+    if (!data.entries.length) {
+        return data.workspaceName
+            ? `No sessions in ${data.workspaceName} yet. Send a message to start.`
+            : 'No sessions yet. Send a message to start.';
+    }
+    const agentBits = Object.entries(data.agentTotals)
+        .map(([agent, count]) => `${agent}×${count}`)
+        .join(' · ');
+    const lines = [
+        `Session digest — ${data.workspaceName || 'workspace'} (${data.total} total${agentBits ? ` · ${agentBits}` : ''})`,
+        '',
+    ];
+    for (const entry of data.entries) {
+        const flags = [
+            entry.isCurrent ? 'current' : null,
+            entry.runState === 'running' ? 'running' : null,
+            entry.runState === 'incomplete' ? 'unfinished' : null,
+        ].filter(Boolean).join(', ');
+        const flagSuffix = flags ? ` [${flags}]` : '';
+        lines.push(`${entry.index}. ${entry.agent} · ${entry.title}${flagSuffix}`);
+        const detail = entry.runDetail ? ` · ${entry.runDetail}` : '';
+        lines.push(`   ${entry.time}${detail}`);
+    }
+    lines.push('', 'Switch: /sessions <#>  ·  Browse: /sessions');
+    return lines.join('\n');
+}
 export function extractLastSessionTurn(messages) {
     if (!messages.length)
         return null;
@@ -479,10 +525,10 @@ export function resolveSkillPrompt(bot, chatId, cmd, args) {
     const paths = getProjectSkillPaths(wd, skill.name);
     const skillFile = paths.claudeSkillFile || paths.sharedSkillFile || paths.agentsSkillFile;
     if (skillFile) {
-        prompt = `${workdirHint}Read the skill definition at \`${skillFile}\` and execute the instructions defined there.${suffix}`;
+        prompt = `${workdirHint}Read the skill definition at \`${relSkillPath(wd, skillFile)}\` and execute the instructions defined there.${suffix}`;
     }
     else {
-        const fallbackPath = `${wd}/.pikiloom/skills/${skill.name}/SKILL.md`;
+        const fallbackPath = relSkillPath(wd, path.join(wd, '.pikiloom', 'skills', skill.name, 'SKILL.md'));
         prompt = `${workdirHint}Read the skill definition at \`${fallbackPath}\` and execute the instructions defined there.${suffix}`;
     }
     return { prompt, skillName: skill.name };

package/dist/bot/menu.js

@@ -31,6 +31,7 @@ export function indexSkillsByCommand(skills) {
 export function buildDefaultMenuCommands(agentCount, skills = []) {
     const commands = [
         { command: 'sessions', description: 'Switch sessions' },
+        { command: 'digest', description: 'Recent session digest' },
     ];
     if (agentCount > 1) {
         commands.push({ command: 'agents', description: 'Switch agents' });

package/dist/bot/session-hub.js

@@ -121,7 +121,7 @@ function imageBlocksFromManagedRecord(record) {
         const abs = path.isAbsolute(rel) ? rel : path.join(record.workspacePath, rel);
         blocks.push({
             type: 'image',
-            // `file://` sentinel — `rewriteImageBlocksForTransport` (dashboard
+            // `file://` sentinel — `rewriteAttachmentBlocksForTransport` (dashboard
             // response layer) converts it to a proper /attachment URL.
             content: `file://${abs}`,
             imagePath: abs,

package/dist/channels/dingtalk/bot.js

@@ -9,7 +9,7 @@ import { BOT_SHUTDOWN_FORCE_EXIT_MS, buildSessionTaskId } from '../../bot/orches
 import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
-import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, } from '../../bot/commands.js';
 import { DingtalkChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -127,6 +127,7 @@ export class DingtalkBot extends Bot {
                     '/switch [path] - Change workdir',
                     '/workspaces [#] - Pick saved workspace',
                     '/sessions [new|#] - List/switch sessions',
+                    '/digest - Recent session digest',
                     '/skills - List project skills',
                     '/stop - Stop current task',
                     '/restart - Restart pikiloom',
@@ -160,6 +161,9 @@ export class DingtalkBot extends Bot {
             case 'sessions':
                 await this.cmdSessions(ctx, args);
                 return true;
+            case 'digest':
+                await this.cmdDigest(ctx);
+                return true;
             case 'skills':
                 await this.cmdSkills(ctx);
                 return true;
@@ -187,6 +191,10 @@ export class DingtalkBot extends Bot {
         lines.push('', 'Ready. Send a message to start.');
         await ctx.reply(lines.join('\n'));
     }
+    async cmdDigest(ctx) {
+        const data = await getSessionsDigestData(this, ctx.chatId);
+        await ctx.reply(formatSessionsDigestText(data));
+    }
     async cmdStatus(ctx) {
         const d = await getStatusDataAsync(this, ctx.chatId);
         const gitLine = formatGitStatusLine(d.git);

package/dist/channels/discord/bot.js

@@ -13,7 +13,7 @@ import { BOT_SHUTDOWN_FORCE_EXIT_MS, buildSessionTaskId } from '../../bot/orches
 import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
-import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getStartData, getWorkspacesData, } from '../../bot/commands.js';
+import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getSessionsDigestData, formatSessionsDigestText, getStartData, getWorkspacesData, } from '../../bot/commands.js';
 import { DiscordChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
 const SHUTDOWN_EXIT_CODE = {
@@ -123,6 +123,7 @@ export class DiscordBot extends Bot {
                     '/switch [path] - Change workdir',
                     '/workspaces [#] - Pick saved workspace',
                     '/sessions [new|#] - List/switch sessions',
+                    '/digest - Recent session digest',
                     '/skills - List project skills',
                     '/stop - Stop current task',
                     '/restart - Restart pikiloom',
@@ -156,6 +157,9 @@ export class DiscordBot extends Bot {
             case 'sessions':
                 await this.cmdSessions(ctx, args);
                 return true;
+            case 'digest':
+                await this.cmdDigest(ctx);
+                return true;
             case 'skills':
                 await this.cmdSkills(ctx);
                 return true;
@@ -183,6 +187,10 @@ export class DiscordBot extends Bot {
         lines.push('', 'Ready. Send a message to start.');
         await ctx.reply(lines.join('\n'));
     }
+    async cmdDigest(ctx) {
+        const data = await getSessionsDigestData(this, ctx.chatId);
+        await ctx.reply(formatSessionsDigestText(data));
+    }
     async cmdStatus(ctx) {
         const d = await getStatusDataAsync(this, ctx.chatId);
         const gitLine = formatGitStatusLine(d.git);

package/dist/channels/feishu/bot.js

@@ -15,7 +15,7 @@ import { stageSessionFiles, } from '../../agent/index.js';
 import { shutdownAllDrivers } from '../../agent/driver.js';
 import { expandTilde } from '../../core/platform.js';
 import { SKILL_CMD_PREFIX, } from '../../bot/menu.js';
-import { getStartData, getSessionsPageData, getModelsListData, getSessionTurnPreviewData, getStatusDataAsync, getHostDataSync, getWorkspacesData, resolveSkillPrompt, handleGoalCommand, } from '../../bot/commands.js';
+import { getStartData, getSessionsPageData, getModelsListData, getSessionTurnPreviewData, getStatusDataAsync, getHostDataSync, getWorkspacesData, resolveSkillPrompt, handleGoalCommand, getSessionsDigestData, formatSessionsDigestText, } from '../../bot/commands.js';
 import { buildAgentsCommandView, buildModelsCommandView, buildModeCommandView, buildSessionsCommandView, buildSkillsCommandView, decodeCommandAction, executeCommandAction, } from '../../bot/command-ui.js';
 import { LivePreview } from '../telegram/live-preview.js';
 import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
@@ -355,6 +355,10 @@ export class FeishuBot extends Bot {
         }
         await this.sendCommandView(ctx, await buildSessionsCommandView(this, ctx.chatId, 0, this.sessionsPageSize));
     }
+    async cmdDigest(ctx) {
+        const data = await getSessionsDigestData(this, ctx.chatId);
+        await ctx.reply(formatSessionsDigestText(data));
+    }
     async cmdStatus(ctx) {
         const d = await getStatusDataAsync(this, ctx.chatId);
         await ctx.reply(renderStatus(d));
@@ -962,6 +966,9 @@ export class FeishuBot extends Bot {
                 case 'sessions':
                     await this.cmdSessions(ctx, args);
                     return;
+                case 'digest':
+                    await this.cmdDigest(ctx);
+                    return;
                 case 'agents':
                     await this.cmdAgents(ctx, args);
                     return;