pikiloom 0.4.26 → 0.4.28

package/dist/bot/command-ui.js

@@ -1,6 +1,3 @@
-/**
- * Shared selection UI models and action executor for interactive commands.
- */
 import { normalizeAgent } from './bot.js';
 import { getDriverCapabilities } from '../agent/driver.js';
 import { getSessionStatusForChat } from './session-status.js';
@@ -36,8 +33,6 @@ export function encodeCommandAction(action) {
         case 'effort.set':
             return `eff:${action.effort}`;
         case 'models.select.model':
-            // Encode native vs profile selection on the wire so decode is unambiguous.
-            // `md:n:<modelId>` = native; `md:p:<profileId>:<modelId>` = BYOK profile.
             return action.profileId
                 ? `md:p:${action.profileId}:${action.modelId}`
                 : `md:n:${action.modelId}`;
@@ -97,8 +92,6 @@ export function decodeCommandAction(data) {
             return { kind: 'models.select.model', modelId, profileId: null };
         }
         if (rest.startsWith('p:')) {
-            // p:<profileId>:<modelId> — profileId is a uuid (no colons), so split on
-            // the first remaining colon yields a clean (profileId, modelId) pair.
             const sep = rest.indexOf(':', 2);
             if (sep < 0)
                 return null;
@@ -108,8 +101,6 @@ export function decodeCommandAction(data) {
                 return null;
             return { kind: 'models.select.model', modelId, profileId };
         }
-        // Legacy callback payloads (pre-union) carried `md:<modelId>` directly.
-        // Treat them as native selections so old buttons in the wild still work.
         if (!rest)
             return null;
         return { kind: 'models.select.model', modelId: rest, profileId: null };
@@ -144,9 +135,6 @@ export function decodeCommandAction(data) {
 }
 export async function buildSessionsCommandView(bot, chatId, page, pageSize = 5) {
     const data = await getSessionsPageData(bot, chatId, page, pageSize);
-    // Multi-row: one button per session on its own line, prefixed with the
-    // agent badge so a mixed workspace list reads cleanly. Avoid cramming
-    // multiple buttons onto one row (some IM clients truncate).
     const sessionButtons = data.sessions.map(session => [{
             label: `[${session.agent}] ${session.title} · ${session.time}`,
             action: { kind: 'session.switch', sessionId: session.key },
@@ -186,16 +174,12 @@ export async function buildSessionsCommandView(bot, chatId, page, pageSize = 5)
 export function buildAgentsCommandView(bot, chatId) {
     const data = getAgentsListData(bot, chatId);
     const installed = data.agents.filter(a => a.installed);
-    // Buttons stay short — friendly label + optional ✓ marker — so they don't
-    // truncate on narrow IM clients.
     const actions = installed.map(agent => ({
         label: agent.label,
         action: { kind: 'agent.switch', agent: agent.agent },
         state: buttonStateFromFlags({ isCurrent: agent.isCurrent }),
         primary: agent.isCurrent,
     }));
-    // Details (version + bound provider) live in the items list above the
-    // buttons, where the renderer can show them in full without truncation.
     const items = installed.map(agent => {
         const main = agent.versionShort
             ? `${agent.label} · v${agent.versionShort}`
@@ -234,17 +218,11 @@ async function initModelsDraft(bot, chatId) {
     modelsDrafts.set(String(chatId), draft);
     return draft;
 }
-/**
- * Section headings for the unified picker. The trailing em-dash padding gives
- * the row a "label" look in Telegram/Feishu — clicking it falls through to a
- * harmless confirm which is a no-op when nothing has changed.
- */
 const MODEL_GROUP_LABELS = {
     native: '— Native —',
     cloud: '— Cloud Profiles —',
     local: '— Local Profiles —',
 };
-/** Match a picker row against the live draft so the "current" pip is unambiguous. */
 function modelRowMatchesDraft(agent, row, draft) {
     if (draft.profileId)
         return !!row.profileId && row.profileId === draft.profileId;
@@ -259,8 +237,6 @@ export async function buildModelsCommandView(bot, chatId, draft) {
         effort: data.effort?.current ?? null,
     };
     modelsDrafts.set(String(chatId), d);
-    // Bucket rows by group while preserving the order resolveAgentModels gave us
-    // (native → cloud → local). We render each non-empty group with a header.
     const groups = {
         native: [],
         cloud: [],
@@ -275,9 +251,6 @@ export async function buildModelsCommandView(bot, chatId, draft) {
         const rawItems = groups[group];
         if (!rawItems.length)
             continue;
-        // Promote the currently-selected row to the top of its group so the user
-        // sees their active pick first without having to scroll. This matches the
-        // pre-union picker's behaviour, just scoped per-group instead of globally.
         const items = [...rawItems].sort((a, b) => Number(modelRowMatchesDraft(data.agent, b, d)) - Number(modelRowMatchesDraft(data.agent, a, d)));
         rows.push([{
                 label: MODEL_GROUP_LABELS[group],
@@ -288,9 +261,6 @@ export async function buildModelsCommandView(bot, chatId, draft) {
         for (const model of items) {
             const selected = modelRowMatchesDraft(data.agent, model, d);
             const labelBase = model.alias || model.id;
-            // For BYOK rows the alias is the Profile name — include provider tag so
-            // two Profiles sharing a model id (e.g. "Sonnet 4.6 · OpenRouter" vs
-            // "Sonnet 4.6 · Anthropic Direct") stay distinguishable in 1-column mode.
             const label = group === 'native' || !model.providerName
                 ? labelBase
                 : `${labelBase} · ${model.providerName}`;
@@ -389,10 +359,6 @@ export function buildModeCommandView(bot, chatId) {
     const metaLines = [];
     if (!isClaude)
         metaLines.push('Permission mode is only available for Claude.');
-    // Workflow orchestration is no longer a standalone toggle here — it folded
-    // into the effort picker as the top "Ultra" rung (max depth + multi-agent
-    // fan-out). Surface its state and point users to /models so the capability
-    // stays discoverable.
     if (supportsWorkflow) {
         metaLines.push(`Workflow orchestration: ${workflowOn ? 'On (Ultra effort)' : 'Off'} — pick the Ultra rung in /models to toggle.`);
     }
@@ -425,8 +391,6 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
         }
         case 'session.switch': {
             const chat = bot.chat(chatId);
-            // Workspace-wide lookup (no agent filter) so a row from any agent can be
-            // resumed directly from a single mixed list.
             const result = await bot.fetchSessions(undefined, bot.chatWorkdir(chatId));
             if (!result.ok)
                 return { kind: 'noop', message: 'Failed to load sessions' };
@@ -435,14 +399,10 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
                 return { kind: 'noop', message: 'Session not found' };
             const prevAgent = chat.agent;
             const runtime = bot.adoptExistingSessionForChat(chatId, session);
-            // Restore the agent's persistent model / effort / Profile binding so the
-            // next stream — and the IM picker chips — match the resumed session.
             if (session.model) {
                 bot.switchModelForChat(chatId, session.model, session.profileId ?? null);
             }
             else if (session.profileId !== undefined) {
-                // Session was native (profileId === null) — explicitly clear any
-                // active Profile so we don't run with a stale BYOK binding.
                 bot.switchModelForChat(chatId, bot.modelForAgent(session.agent), null);
             }
             if (session.thinkingEffort) {
@@ -532,8 +492,6 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
         case 'models.select.model': {
             const draft = modelsDrafts.get(String(chatId)) ?? await initModelsDraft(bot, chatId);
             draft.modelId = action.modelId;
-            // profileId can be null (native pick) or a uuid (BYOK pick). Treating
-            // `undefined` as "leave alone" preserves the action shape's old contract.
             if (action.profileId !== undefined)
                 draft.profileId = action.profileId;
             return { kind: 'view', view: await buildModelsCommandView(bot, chatId, draft), callbackText: '' };
@@ -561,9 +519,6 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
             }
             const parts = [];
             if (modelChanged) {
-                // Pass profileId explicitly: a null clears any active Profile binding,
-                // a uuid binds the picked Profile. switchModelForChat handles both
-                // sides of the dual path so call sites stay agnostic.
                 bot.switchModelForChat(chatId, draft.modelId, draft.profileId ?? null);
                 parts.push(draft.profileId ? `Profile: ${draft.modelId}` : `Model: ${draft.modelId}`);
             }

package/dist/bot/commands.js

@@ -1,13 +1,3 @@
-/**
- * bot-commands.ts — channel-agnostic command data layer.
- *
- * Each function returns structured data objects that any IM renderer can consume.
- * No rendering, no HTML, no platform-specific formatting.
- *
- * Usage from a channel-specific bot (e.g. bot-telegram.ts, bot-feishu.ts):
- *   const data = await getSessionsPageData(bot, chatId, 0);
- *   const rendered = renderSessionsPage(data); // channel-specific renderer
- */
 import path from 'node:path';
 import fs from 'node:fs';
 import { fmtTokens, fmtUptime, fmtBytes } from './bot.js';
@@ -65,20 +55,6 @@ export function getWorkspacesData(bot, chatId) {
     });
     return { currentWorkdir, workspaces };
 }
-// ---------------------------------------------------------------------------
-// Goal — channel-agnostic /goal command dispatch
-// ---------------------------------------------------------------------------
-/**
- * Handle /goal <args> for a chat. Returns a human-readable status line for
- * the IM renderer to send back. Returns null when there is no active session
- * for the chat (caller renders its own "pick a session first" message).
- *
- * Per-agent routing:
- *   - codex → native `thread/goal/*` RPC (state machine + budget + pause/resume)
- *   - claude → native `/goal <condition>` slash command (Stop hook continuation,
- *              auto-clear on completion, no budget / no pause/resume)
- *   - others → pikiloom's portable goal.json with continuation injection
- */
 export async function handleGoalCommand(bot, chatId, rawArgs) {
     const session = bot.selectedSession(chatId);
     if (!session || !session.sessionId)
@@ -199,9 +175,6 @@ export function summarizeSessionRun(session) {
 }
 export async function getSessionsPageData(bot, chatId, page, pageSize = 5) {
     const cs = bot.chat(chatId);
-    // Workspace-wide: drop the cs.agent filter so the list matches what the
-    // dashboard shows for this workspace (all installed agents, sorted by
-    // most-recent activity).
     const res = await bot.fetchSessions(undefined, bot.chatWorkdir(chatId));
     const sessions = res.ok ? res.sessions : [];
     const total = sessions.length;
@@ -332,14 +305,6 @@ function agentDisplayLabel(agentId) {
     return AGENT_LABEL_OVERRIDES[agentId]
         || agentId.charAt(0).toUpperCase() + agentId.slice(1);
 }
-/**
- * Pull the first semver-ish token out of a CLI `--version` string. Falls back
- * to the original string when no semver is present.
- *
- *   "2.1.132 (Claude Code v2.1.132)"  → "2.1.132"
- *   "Hermes Agent v0.12.0 (2026.4.30)" → "0.12.0"
- *   "codex-cli 0.128.0"                → "0.128.0"
- */
 function shortVersion(raw) {
     if (!raw)
         return null;
@@ -422,9 +387,6 @@ const EFFORT_LEVELS = {
         { id: 'high', label: 'High' },
         { id: 'xhigh', label: 'Very High' },
         { id: 'max', label: 'Max' },
-        // Synthetic top rung: "max depth + multi-agent Workflow orchestration", the
-        // same bundle as Claude's `ultracode` mode. Not a real --effort value — the
-        // bot decomposes it into (effort=max, workflow=on) at apply time.
         { id: 'ultra', label: 'Ultra' },
     ],
     codex: [
@@ -442,8 +404,6 @@ const EFFORT_LEVELS = {
     ],
 };
 function buildEffortData(bot, agent) {
-    // Display value folds workflow into the synthetic `ultra` rung — see
-    // Bot.effortSelectionForAgent.
     const currentEffort = bot.effortSelectionForAgent(agent);
     if (!currentEffort)
         return null;
@@ -460,11 +420,6 @@ export async function getModelsListData(bot, chatId) {
     const currentModel = bot.modelForAgent(cs.agent);
     const activeProfileId = bot.activeProfileIdForAgent(cs.agent);
     const res = await bot.fetchModels(cs.agent, bot.chatWorkdir(chatId));
-    // Match priority:
-    //   - if a Profile is bound, only the row carrying that profileId is current
-    //     (two Profiles can share a modelId, so id-equality alone is ambiguous);
-    //   - otherwise only `'native'` rows are eligible to match against the
-    //     user-config model id.
     return {
         agent: cs.agent,
         currentModel,
@@ -504,9 +459,6 @@ export async function getStatusDataAsync(bot, chatId) {
 export function getHostDataSync(bot) {
     return bot.getHostData();
 }
-// ---------------------------------------------------------------------------
-// Skill routing
-// ---------------------------------------------------------------------------
 export { SKILL_CMD_PREFIX, indexSkillsByCommand };
 function relSkillPath(workdir, filePath) {
     const relative = path.relative(workdir, filePath).replace(/\\/g, '/');
@@ -553,7 +505,4 @@ export function getExtensionSummaryData(bot, chatId) {
         })),
     };
 }
-// ---------------------------------------------------------------------------
-// Re-export commonly used helpers for convenience
-// ---------------------------------------------------------------------------
 export { summarizePromptForStatus, fmtTokens, fmtUptime, fmtBytes, VERSION };

package/dist/bot/headless-bot.js

@@ -1,27 +1,6 @@
-/**
- * HeadlessBot — the Web Dashboard acting as a first-class terminal.
- *
- * pikiloom's terminals (IM channels and the Dashboard) are equal, pluggable
- * entry points. The IM channels each have a Bot subclass that connects a chat
- * transport; the Dashboard needs no transport — it drives the bot directly via
- * `runtime.getBotRef()`. HeadlessBot fills that gap: it satisfies the Bot
- * contract (`run()` / `requestStop()`) so `ChannelSupervisor` can manage its
- * lifecycle exactly like a channel bot and the dashboard can attach to it for
- * live stream snapshots — but it connects to nothing.
- *
- * It exists so the bot is usable with zero IM channels configured: install an
- * agent, open the dashboard, and you have a working terminal. When an IM
- * channel is later added, the supervisor tears this down and the channel's bot
- * takes over the dashboard attachment.
- */
 import { Bot } from './bot.js';
 export class HeadlessBot extends Bot {
     resolveRun = null;
-    /**
-     * No transport to connect — just mark the terminal live and block until
-     * `requestStop()` so the supervisor's lifecycle (await runPromise on stop)
-     * matches the channel bots'.
-     */
     run() {
         this.connected = true;
         this.log('dashboard terminal ready (no IM channel configured)');

package/dist/bot/host.js

@@ -1,7 +1,3 @@
-/**
- * Host system data collection: battery, CPU, memory, display name.
- * Platform-adaptive with macOS, Linux, and Windows support.
- */
 import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -175,7 +171,7 @@ export function getHostDisplayName() {
             if (name)
                 return name;
         }
-        catch { /* fall through */ }
+        catch { }
     }
     return os.hostname();
 }

package/dist/bot/human-loop.js

@@ -1,6 +1,3 @@
-/**
- * Human-in-the-loop prompt state machine and answer helpers.
- */
 export function createEmptyHumanLoopAnswer() {
     return {
         selectedValue: null,
@@ -125,11 +122,6 @@ function displayValueForOption(question, value) {
     const match = question.options?.find(opt => opt.value === value);
     return match?.label || value;
 }
-/**
- * Build a channel-agnostic summary of a prompt's resolved answers. Used by the
- * base bot's `onInteractionAnswered` hook so each channel renders the same
- * closed-state view + echo message without diverging.
- */
 export function summarizeResolvedHumanLoopAnswers(prompt, status = 'answered') {
     const rows = [];
     const compactParts = [];

package/dist/bot/menu.js

@@ -1,6 +1,3 @@
-/**
- * Menu command definitions and skill-to-command mapping.
- */
 export const SKILL_CMD_PREFIX = 'sk_';
 export function buildWelcomeIntro(version) {
     return {

package/dist/bot/orchestration.js

@@ -1,6 +1,3 @@
-/**
- * Session and message orchestration helpers shared across channels.
- */
 import { buildDefaultMenuCommands } from './menu.js';
 import { BOT_SHUTDOWN_FORCE_EXIT_MS as _BOT_SHUTDOWN_FORCE_EXIT_MS } from '../core/constants.js';
 export const BOT_SHUTDOWN_FORCE_EXIT_MS = _BOT_SHUTDOWN_FORCE_EXIT_MS;

package/dist/bot/render-shared.js

@@ -1,18 +1,8 @@
-/**
- * Shared rendering utilities used by channel-specific renderers.
- *
- * Contains types, pure-data helpers, and functions that are identical across platforms.
- * Platform-specific formatting (HTML vs Markdown) stays in the respective render files.
- */
 import { materializeImage } from '../agent/index.js';
 import { fmtUptime, formatThinkingForDisplay, thinkLabel } from './bot.js';
 import { formatActivityCommandSummary, parseActivitySummary, renderPlanForPreview, summarizeActivityForPreview } from './streaming.js';
 import { supportsChannelCapability } from '../channels/base.js';
 import { agentLog, agentWarn } from '../agent/index.js';
-// ---------------------------------------------------------------------------
-// GFM table parsing
-// ---------------------------------------------------------------------------
-/** Parse GFM table lines into structured headers + rows. */
 export function parseGfmTable(tableLines) {
     if (tableLines.length < 3)
         return null;
@@ -39,9 +29,6 @@ export function parseGfmTable(tableLines) {
     }
     return rows.length ? { headers, rows } : null;
 }
-// ---------------------------------------------------------------------------
-// Footer helpers
-// ---------------------------------------------------------------------------
 export function fmtCompactUptime(ms) {
     return fmtUptime(ms).replace(/\s+/g, '');
 }
@@ -52,12 +39,6 @@ export function footerStatusSymbol(status) {
         case 'failed': return '✗';
     }
 }
-/**
- * Drop a leading `provider/` segment from long model ids so the footer stays
- * readable on narrow IM clients. `anthropic/claude-sonnet-4` → `claude-sonnet-4`,
- * `deepseek/deepseek-v4-flash` → `deepseek-v4-flash`. Already-short ids are
- * returned unchanged.
- */
 function compactModelLabel(model) {
     const trimmed = model.trim();
     if (trimmed.length <= 24)
@@ -65,12 +46,6 @@ function compactModelLabel(model) {
     const slashIdx = trimmed.indexOf('/');
     return slashIdx > 0 ? trimmed.slice(slashIdx + 1) : trimmed;
 }
-/**
- * Split footer fields into a primary identity line (agent + model) and a
- * secondary runtime line (effort, context%, elapsed). Channel renderers
- * compose the two lines with their own visual styling so narrow IM clients
- * never have to soft-wrap a single dense line.
- */
 export function formatFooterParts(agent, elapsedMs, meta, contextPercent, decorations) {
     const identityParts = [agent];
     if (decorations?.model)
@@ -82,10 +57,6 @@ export function formatFooterParts(agent, elapsedMs, meta, contextPercent, decora
     if (ctx != null)
         runtimeParts.push(`${ctx}%`);
     runtimeParts.push(fmtCompactUptime(Math.max(0, Math.round(elapsedMs))));
-    // BYOK attribution — tells the user the turn is being routed through a
-    // third-party provider rather than the agent CLI's native auth path.
-    // Tucked at the end of the runtime line so it doesn't crowd the (often
-    // long) identity line on narrow IM clients.
     const providerName = meta?.providerName ?? decorations?.provider ?? null;
     if (providerName)
         runtimeParts.push(`via ${providerName}`);
@@ -94,23 +65,11 @@ export function formatFooterParts(agent, elapsedMs, meta, contextPercent, decora
         runtime: runtimeParts.join(' · '),
     };
 }
-// ---------------------------------------------------------------------------
-// Activity trimming
-// ---------------------------------------------------------------------------
-/**
- * Trim the activity narrative for a streaming preview. Keeps the **most
- * recent** lines that fit the budget — the user is watching the turn live,
- * what just happened matters far more than what happened 30 tool-calls ago.
- * A leading `...` marker signals "earlier activity dropped" when truncation
- * happens; the tail order is preserved.
- */
 export function trimActivityForPreview(text, maxChars = 900) {
     if (text.length <= maxChars)
         return text;
     const lines = text.split('\n').filter(line => line.trim());
     if (lines.length <= 1) {
-        // Single very-long line — keep the trailing characters with a leading
-        // ellipsis so the freshest content is visible.
         return '...' + text.slice(text.length - Math.max(0, maxChars - 3));
     }
     const ellipsis = '...';
@@ -132,9 +91,6 @@ export function trimActivityForPreview(text, maxChars = 900) {
         return tail.join('\n');
     return [ellipsis, ...tail].join('\n');
 }
-// ---------------------------------------------------------------------------
-// Provider usage (plain-text builder — caller wraps as needed)
-// ---------------------------------------------------------------------------
 function rawUsageLine(parts) {
     return parts.filter(part => !!part && String(part).trim()).join(' ');
 }
@@ -167,15 +123,6 @@ export function buildProviderUsageLines(usage) {
     }
     return lines;
 }
-/**
- * Iterate an assistant turn's image MessageBlocks and dispatch each through
- * the channel's `sendImage` capability. No-op when the channel doesn't claim
- * `sendImage`. Errors per image are logged but don't block the rest of the
- * dispatch — the text reply path is responsible for the user-visible summary.
- *
- * Returns the list of `{messageId, caption}` entries so the caller can register
- * them with the session for "reply to continue" linkage.
- */
 export async function dispatchImageBlocks(channel, blocks, opts) {
     if (!blocks?.length)
         return [];
@@ -253,13 +200,6 @@ export function extractFinalReplyData(agent, result) {
         elapsedMs,
     };
 }
-/**
- * Build the sub-agent block for the streaming preview. Sub-agents are
- * deliberately isolated from parent activity (their tool list lives on each
- * StreamSubAgent record), so we render a separate compact section showing each
- * sub-agent's purpose + latest tool. Completed sub-agents are hidden — the
- * parent's activity already reflects the Task `done` line.
- */
 function renderSubAgentsForPreview(meta) {
     const subs = meta?.subAgents;
     if (!subs?.length)
@@ -288,9 +228,6 @@ export function extractStreamPreviewData(input) {
     const label = thinkLabel(input.agent);
     const thinkSnippet = rawThinking ? formatThinkingForDisplay(input.thinking, 600) : '';
     const preview = display.length > maxBody ? '(...truncated)\n' + display.slice(-maxBody) : display;
-    // Elapsed time is the only monotonic progress signal available during the
-    // thinking phase (see thinkingProgressText). Hidden in the first second so a
-    // freshly-opened card doesn't flash "0s".
     const elapsedMs = Math.max(0, input.elapsedMs);
     const thinkingProgressText = elapsedMs >= 1000 ? fmtCompactUptime(elapsedMs) : null;
     return {