pikiloom 0.4.26 → 0.4.28

package/dist/cli/main.js

@@ -1,14 +1,6 @@
 #!/usr/bin/env node
-/**
- * cli.ts — CLI entry point for pikiloom.
- */
-// Mark this process as a Claude Code context so nested claude launches are blocked.
-// The spawn framework in code-agent.ts strips this before launching agent subprocesses.
 process.env.CLAUDECODE = '1';
 import { hydrateLegacyEnv, migrateLegacyStateDir } from '../core/legacy-compat.js';
-// Backward-compat for the pikiclaw → pikiloom rename. Runs before any config is
-// read or lock taken: mirror PIKICLAW_* → PIKILOOM_* and move ~/.pikiclaw →
-// ~/.pikiloom. Both are idempotent no-ops once an install has migrated.
 hydrateLegacyEnv();
 migrateLegacyStateDir();
 import { spawn } from 'node:child_process';
@@ -27,7 +19,6 @@ import { runSetupWizard } from './setup-wizard.js';
 import { FROM_LAUNCHD_ENV, maybePromptAutostart } from './autostart.js';
 import { applyUserConfig, loadUserConfig, startUserConfigSync, updateUserConfig, } from '../core/config/user-config.js';
 import { VERSION } from '../core/version.js';
-/* ── Daemon (watchdog) mode ─────────────────────────────────────────── */
 const DAEMON_RESTART_DELAY_MS = DAEMON_TIMEOUTS.restartDelay;
 const DAEMON_MAX_RESTART_DELAY_MS = DAEMON_TIMEOUTS.maxRestartDelay;
 const DAEMON_RAPID_CRASH_WINDOW_MS = DAEMON_TIMEOUTS.rapidCrashWindow;
@@ -35,28 +26,13 @@ function daemonLog(msg) {
     const ts = new Date().toTimeString().slice(0, 8);
     process.stdout.write(`[daemon ${ts}] ${msg}\n`);
 }
-/** Args that are daemon-specific and should not be forwarded to the child. */
 const DAEMON_STRIP_ARGS = new Set(['--daemon', '--no-daemon']);
-/**
- * Runs the bot as a supervised child process. On non-zero exit the child is
- * restarted with exponential back-off. A clean exit (code 0) stops the daemon.
- * Restart requests use a dedicated exit code and are respawned immediately.
- */
 async function runDaemon(userArgs) {
-    // Forward user's CLI args (strip daemon-related flags).
     const forwardedArgs = userArgs.filter(a => !DAEMON_STRIP_ARGS.has(a));
     const restartCmd = process.env.PIKILOOM_RESTART_CMD;
     const restartStateFile = createRestartStateFilePath(process.pid);
-    // Publish the daemon PID so `pikiloom stop` can find it. Clean up on any
-    // exit path so a stale file never points at someone else's PID.
     writeDaemonPidFile(process.pid);
     process.once('exit', clearDaemonPidFile);
-    // Auto-start enrollment: only when the user explicitly typed `--daemon`
-    // (the watchdog itself is on by default, so we use the explicit flag as
-    // the signal of "I'm settling in for long-term use"). Fire-and-forget so
-    // the bot still comes up immediately; the dialog appears a few seconds
-    // later. No-op when already enrolled, declined, non-interactive, or
-    // already running under launchd — see src/cli/autostart.ts.
     if (userArgs.includes('--daemon')) {
         maybePromptAutostart(daemonLog);
     }
@@ -67,7 +43,6 @@ async function runDaemon(userArgs) {
         clearRestartStateFile(restartStateFile);
         const { bin, args } = buildRestartCommand(forwardedArgs, restartCmd);
         daemonLog(`exec: ${bin} ${args.join(' ')}`);
-        // npx/npx.cmd needs shell resolution; node.exe does not
         const needsShell = process.platform === 'win32' && !bin.endsWith('node.exe');
         return spawn(needsShell ? `"${bin}"` : bin, args, {
             stdio: 'inherit',
@@ -90,7 +65,6 @@ async function runDaemon(userArgs) {
         daemonLog(`child running (pid=${child.pid})`);
         const startedAt = Date.now();
         let shutdownSignal = null;
-        // Forward termination and restart signals to the active child.
         const forwardShutdownSignal = (sig) => {
             shutdownSignal = sig;
             child.kill(sig);
@@ -118,15 +92,13 @@ async function runDaemon(userArgs) {
             daemonLog('child requested restart, respawning immediately');
             continue;
         }
-        // Clean exit → stop daemon.
         if (code === 0 || code === null) {
             daemonLog(`child exited cleanly (code=${code}), daemon stopping`);
             process.exit(0);
         }
-        // Exponential back-off for rapid crashes.
         const uptime = Date.now() - startedAt;
         if (uptime > DAEMON_RAPID_CRASH_WINDOW_MS) {
-            restartDelay = DAEMON_RESTART_DELAY_MS; // reset if it ran for a while
+            restartDelay = DAEMON_RESTART_DELAY_MS;
         }
         else {
             restartDelay = Math.min(restartDelay * 2, DAEMON_MAX_RESTART_DELAY_MS);
@@ -215,15 +187,12 @@ function parseArgs(argv) {
     }
     return args;
 }
-/* ── Shared helpers ────────────────────────────────────────────────── */
 function processLog(message) {
     const ts = new Date().toTimeString().slice(0, 8);
     process.stdout.write(`[pikiloom ${ts}] ${message}\n`);
 }
 const listStartupAgents = () => listAgents().agents;
 const listVerboseAgents = () => listAgents({ includeVersion: true }).agents;
-/* ── Phase: early exits (MCP serve, --version, --help) ────────────── */
-/** If launched as an MCP stdio server, run that and exit. */
 async function handleMcpServeMode() {
     if (process.argv.includes('--mcp-serve')) {
         await import('../agent/mcp/session-server.js');
@@ -231,7 +200,6 @@ async function handleMcpServeMode() {
     }
     return false;
 }
-/** Print help text and exit. */
 function printHelp() {
     process.stdout.write(`pikiloom v${VERSION} — Run local coding agents through IM.
 
@@ -321,28 +289,11 @@ Docs: https://github.com/xiaotonng/pikiloom
 `);
     process.exit(0);
 }
-/* ── Phase: workdir persistence & daemon handoff ──────────────────── */
-/**
- * For a fresh CLI launch (not a daemon-managed child), persist the working
- * directory into setting.json so the bot defaults to where the user invoked
- * the command. An explicit `-w` always wins and is saved. Without `-w`, a
- * previously saved workdir (including one chosen later in the dashboard) is
- * kept as-is; we only fall back to the launch cwd on first run, when nothing
- * has been saved yet, so relaunching never silently reverts the workdir.
- */
 function persistWorkdir(args, userConfig) {
     if (process.env.PIKILOOM_DAEMON_CHILD)
         return userConfig;
-    // launchd launches the process from `/`; without `-w`, that would clobber
-    // the user's saved workdir to "/". Skip persistence so the config stays
-    // whatever the user previously chose interactively.
     if (process.env[FROM_LAUNCHD_ENV])
         return userConfig;
-    // An explicit `-w` is a deliberate choice and always wins. Without it, a
-    // workdir the user already saved (e.g. picked in the dashboard via
-    // `/api/switch-workdir`) must survive relaunch — otherwise every fresh
-    // `npx pikiloom` silently reverts the workdir to its launch cwd. Only fall
-    // back to cwd on first run, when nothing has been saved yet.
     const explicitWorkdir = typeof args.workdir === 'string' && args.workdir.trim()
         ? args.workdir.trim()
         : '';
@@ -354,21 +305,14 @@ function persistWorkdir(args, userConfig) {
     updateUserConfig({ workdir: nextWorkdir });
     return loadUserConfig();
 }
-/**
- * If daemon mode is active and we are the top-level process, become the
- * watchdog. This function never returns in daemon mode.
- */
 async function enterDaemonIfNeeded(args) {
     if (args.daemon && !process.env.PIKILOOM_DAEMON_CHILD) {
         await runDaemon(process.argv.slice(2));
     }
     if (!args.daemon) {
-        // --no-daemon: clear inherited env so requestProcessRestart uses the
-        // direct-spawn path instead of handing off to a non-existent daemon.
         delete process.env.PIKILOOM_DAEMON_CHILD;
     }
 }
-/** Install SIGUSR2 restart handler and clean it up on exit. */
 function installRestartSignalHandler() {
     const onSigusr2 = () => {
         processLog('SIGUSR2 received, restarting...');
@@ -379,21 +323,12 @@ function installRestartSignalHandler() {
         process.off('SIGUSR2', onSigusr2);
     });
 }
-/**
- * Top-level shutdown safety net. Channels install their own SIGINT/SIGTERM
- * handlers that do per-channel cleanup with a 3 s unref-ed force-exit timer,
- * but those handlers only exist while a channel is running and silently fail
- * if cleanup throws before the timer is set. This handler is the last-resort
- * guarantee: once the user hits Ctrl+C, the process exits within the grace
- * window no matter what state we're in.
- */
 function installTopLevelShutdownHandler() {
     const GRACE_MS = 5_000;
     let shuttingDown = false;
     const onSignal = (sig) => {
         const exitCode = sig === 'SIGINT' ? 130 : 143;
         if (shuttingDown) {
-            // Second Ctrl+C — bail immediately.
             processLog(`${sig} again, forcing immediate exit`);
             process.exit(exitCode);
         }
@@ -404,12 +339,6 @@ function installTopLevelShutdownHandler() {
     process.on('SIGINT', () => onSignal('SIGINT'));
     process.on('SIGTERM', () => onSignal('SIGTERM'));
 }
-/* ── Phase: stop subcommand ───────────────────────────────────────── */
-/**
- * Find and terminate the running daemon. Reads the PID file written by
- * `runDaemon`, sends SIGTERM, waits briefly, escalates to SIGKILL if the
- * process is still alive. Never returns — always exits.
- */
 async function handleStopCommand() {
     const pid = readDaemonPidFile();
     if (!pid) {
@@ -435,7 +364,6 @@ async function handleStopCommand() {
         process.exit(1);
     }
     process.stdout.write(`pikiloom stop: SIGTERM → pid ${pid}\n`);
-    // Poll for up to 8 s; daemon's child needs ~3 s for its force-exit timer.
     const deadline = Date.now() + 8_000;
     while (Date.now() < deadline) {
         if (!isProcessAlive(pid)) {
@@ -445,7 +373,6 @@ async function handleStopCommand() {
         }
         await new Promise(resolve => setTimeout(resolve, 250));
     }
-    // Escalate to SIGKILL.
     process.stderr.write(`pikiloom stop: daemon (pid ${pid}) still alive after 8s, sending SIGKILL\n`);
     try {
         process.kill(pid, 'SIGKILL');
@@ -454,8 +381,6 @@ async function handleStopCommand() {
     clearDaemonPidFile();
     process.exit(0);
 }
-/* ── Phase: doctor check ──────────────────────────────────────────── */
-/** Run setup diagnostics and exit (--doctor). */
 function runDoctorCheck(channel, tokenProvided) {
     const setupState = collectSetupState({
         agents: listVerboseAgents(),
@@ -470,11 +395,6 @@ function runDoctorCheck(channel, tokenProvided) {
         process.stderr.write(guide);
     process.exit(ready ? 0 : 1);
 }
-/* ── Phase: setup (dashboard / wizard / guide) ────────────────────── */
-/**
- * Poll the dashboard until the user completes configuration.
- * Mutates `ctx` in place with freshly resolved channels.
- */
 async function awaitDashboardConfig(dashboard, ctx) {
     const ts = new Date().toTimeString().slice(0, 8);
     process.stdout.write(`[pikiloom ${ts}] waiting for configuration via dashboard...\n`);
@@ -493,9 +413,6 @@ async function awaitDashboardConfig(dashboard, ctx) {
             channel,
             tokenProvided: channels.length > 0 && hasConfiguredChannelToken({ ...ctx.userConfig, ...ctx.configOverrides }, channel, ctx.args.token),
         });
-        // Dashboard-as-terminal: an installed agent is the only prerequisite to
-        // start. IM channels are optional — the dashboard is itself a terminal, so
-        // don't block startup waiting for a channel token.
         const nextNeedsSetup = !hasReadyAgent(nextSetupState);
         if (!nextNeedsSetup) {
             const resumeTs = new Date().toTimeString().slice(0, 8);
@@ -504,10 +421,6 @@ async function awaitDashboardConfig(dashboard, ctx) {
         }
     }
 }
-/**
- * Run the setup phase: dashboard wait-loop, terminal wizard, or guide printout.
- * Returns the dashboard instance (if started) and possibly-updated userConfig.
- */
 async function runSetupPhase(args, userConfig, configOverrides, channels, channel, tokenProvided) {
     const setupState = collectSetupState({
         agents: listStartupAgents(),
@@ -516,16 +429,10 @@ async function runSetupPhase(args, userConfig, configOverrides, channels, channe
     });
     const useDashboard = !args.noDashboard && !args.setup;
     let dashboard = null;
-    // With the dashboard as a terminal, an installed agent is enough to start.
-    // Without the dashboard (headless server / --no-dashboard), an IM channel is
-    // still required as the only terminal.
     const needsSetup = useDashboard
         ? !hasReadyAgent(setupState)
         : (channels.length === 0 || !tokenProvided || !hasReadyAgent(setupState));
     if (useDashboard) {
-        // Suppress the browser pop on auto-start when there's no user-facing
-        // terminal: launchd-spawned bots, Docker/headless server runs, or when
-        // the user explicitly set PIKILOOM_OPEN_BROWSER=0.
         const openBrowser = !args.server
             && !process.env[FROM_LAUNCHD_ENV]
             && !envBool('PIKILOOM_DOCKER', false)
@@ -568,7 +475,6 @@ async function runSetupPhase(args, userConfig, configOverrides, channels, channe
     }
     return { dashboard, userConfig, channels, channel };
 }
-/** Print the shareable connection code for `--server` (headless) mode. */
 function printServerConnectionCode(dashboard) {
     const c = loadUserConfig();
     const sc = buildServerCode({
@@ -590,13 +496,6 @@ function printServerConnectionCode(dashboard) {
         process.stdout.write('  paste it into a client → 连接 → 互联网/局域网.\n\n');
     }
 }
-/* ── Phase: post-setup validation ─────────────────────────────────── */
-/**
- * Re-resolve channels after the setup phase and validate we have a runnable
- * terminal: an installed agent is mandatory; an IM channel is required only
- * when the dashboard isn't serving as the terminal. Exits on failure.
- * Returns the (possibly empty) channel set — empty is valid in dashboard mode.
- */
 function validatePostSetupChannels(configOverrides, userConfig, args, useDashboard) {
     const effectiveConfig = { ...userConfig, ...configOverrides };
     const channels = resolveConfiguredChannels({
@@ -609,28 +508,18 @@ function validatePostSetupChannels(configOverrides, userConfig, args, useDashboa
         channel,
         tokenProvided: channels.length > 0,
     });
-    // An installed agent is the hard requirement — no terminal can run a session
-    // without one.
     if (!hasReadyAgent(refreshedSetupState)) {
         process.stderr.write(buildSetupGuide(refreshedSetupState, VERSION, { doctor: true }));
         process.exit(1);
     }
-    // Zero IM channels is fine when the dashboard is the terminal; only bail when
-    // there's no terminal at all (dashboard disabled AND no channel configured).
     if (channels.length === 0 && !useDashboard) {
         process.stdout.write(buildSetupGuide(refreshedSetupState, VERSION));
         process.exit(0);
     }
     return { channels, channel };
 }
-/* ── Phase: runtime config & env setup ────────────────────────────── */
-/**
- * Build the final runtime config, apply token/model/permission overrides to
- * the environment, start config file sync, and kick off agent auto-update.
- */
 function applyRuntimeConfig(args, userConfig, configOverrides, channel) {
     const runtimeConfig = { ...userConfig, ...configOverrides };
-    // Inject CLI token into channel-specific config fields.
     if (args.token) {
         if (channel === 'telegram')
             runtimeConfig.telegramBotToken = args.token;
@@ -648,7 +537,6 @@ function applyRuntimeConfig(args, userConfig, configOverrides, channel) {
         agents: listAgents({ includeVersion: true, refresh: true }).agents,
         log: processLog,
     });
-    // Model override: route to the correct agent env var.
     if (args.model) {
         const ag = args.agent || runtimeConfig.defaultAgent || 'codex';
         if (ag === 'codex')
@@ -660,7 +548,6 @@ function applyRuntimeConfig(args, userConfig, configOverrides, channel) {
     }
     if (args.timeout != null)
         process.env.PIKILOOM_TIMEOUT = String(args.timeout);
-    // Permission mode: safe vs full-access.
     if (args.safeMode) {
         process.env.CODEX_FULL_ACCESS = 'false';
         process.env.CLAUDE_PERMISSION_MODE = 'default';
@@ -673,12 +560,6 @@ function applyRuntimeConfig(args, userConfig, configOverrides, channel) {
         process.env.GEMINI_APPROVAL_MODE = 'yolo';
         process.env.GEMINI_SANDBOX = 'false';
     }
-    // Live-reload config file sync.
-    //
-    // Only pass overrides that came from CLI flags / explicit args, NOT the full
-    // runtimeConfig. Otherwise a snapshot of every user-managed field (model,
-    // effort, workdir, etc.) gets re-applied on every sync tick, silently
-    // reverting changes the user just made via the menu or dashboard.
     const syncOverrides = {};
     if (args.agent)
         syncOverrides.defaultAgent = args.agent;
@@ -700,25 +581,12 @@ function applyRuntimeConfig(args, userConfig, configOverrides, channel) {
     process.once('exit', stopUserConfigSync);
     return runtimeConfig;
 }
-/* ── Phase: channel launch ────────────────────────────────────────── */
-/**
- * Hand off channel lifecycle to ChannelSupervisor and block forever. The
- * supervisor reconciles bots against the user config — adding, removing,
- * or replacing channels in response to dashboard saves without restarting
- * the pikiloom process.
- *
- * Per-bot signal handlers (and the daemon supervisor when present) drive
- * process exit; this promise is just a foreground keep-alive.
- */
 async function launchChannels(channels, dashboard) {
     processLog(`launching channels: ${channels.join(', ')}`);
     const supervisor = new ChannelSupervisor({ dashboard, log: processLog });
     await supervisor.start();
-    // Block forever — the dashboard HTTP listener and per-channel signal
-    // handlers keep the process alive and drive shutdown.
     await new Promise(() => { });
 }
-/* ── main() ───────────────────────────────────────────────────────── */
 export async function main() {
     if (await handleMcpServeMode())
         return;
@@ -732,37 +600,25 @@ export async function main() {
         printHelp();
     if (args.stop)
         await handleStopCommand();
-    // Persist workdir for fresh (non-daemon-child) launches.
     userConfig = persistWorkdir(args, userConfig);
-    // Daemon mode: become watchdog (never returns in daemon mode).
     await enterDaemonIfNeeded(args);
-    // Child / no-daemon process: install restart signal handler + top-level
-    // shutdown safety net so Ctrl+C always brings the process down.
     installRestartSignalHandler();
     installTopLevelShutdownHandler();
-    // Apply config overrides from CLI args.
     const configOverrides = {};
     if (args.agent)
         configOverrides.defaultAgent = args.agent;
     applyUserConfig({ ...userConfig, ...configOverrides }, undefined, { overwrite: true, clearMissing: true });
-    // Resolve initial channels.
     const effectiveConfig = () => ({ ...userConfig, ...configOverrides });
     let channels = resolveConfiguredChannels({ config: effectiveConfig(), tokenOverride: args.token });
     let channel = channels[0] || 'feishu';
     const tokenProvided = channels.length > 0 && hasConfiguredChannelToken(effectiveConfig(), channel, args.token);
-    // Doctor mode: check and exit.
     if (args.doctor)
         runDoctorCheck(channel, tokenProvided);
-    // Setup phase: dashboard, wizard, or guide.
     const useDashboard = !args.noDashboard && !args.setup;
     let dashboard;
     ({ dashboard, userConfig, channels, channel } = await runSetupPhase(args, userConfig, configOverrides, channels, channel, tokenProvided));
-    // Validate the terminal is runnable after setup (channels may be empty when
-    // the dashboard is serving as the terminal).
     ({ channels, channel } = validatePostSetupChannels(configOverrides, userConfig, args, useDashboard));
-    // Apply runtime config, env overrides, and start config sync.
     applyRuntimeConfig(args, userConfig, configOverrides, channel);
-    // Launch bot channel(s).
     await launchChannels(channels, dashboard);
 }
 main().catch(err => { console.error(err); process.exit(1); });

package/dist/cli/onboarding.js

@@ -1,6 +1,3 @@
-/**
- * Setup/doctor state assessment and messaging.
- */
 import { getAgentInstallCommand, getAgentLabel } from '../agent/npm.js';
 function enrichAgent(agent) {
     const label = getAgentLabel(agent.agent);
@@ -118,9 +115,6 @@ export function hasInstalledAgent(state) {
     return state.agents.some(agent => agent.installed);
 }
 export function isSetupReady(state) {
-    // The Web Dashboard is always an available terminal, so an installed agent is
-    // the only hard prerequisite. IM channels are optional add-ons — their
-    // readiness is surfaced separately (per-channel status), not gated here.
     return hasReadyAgent(state);
 }
 export function buildSetupGuide(state, version, options) {

package/dist/cli/run.js

@@ -1,12 +1,4 @@
 #!/usr/bin/env node
-/**
- * run.ts — Standalone CLI commands for pikiloom.
- *
- * Usage:
- *   npm run command -- status
- *   npm run command -- claude-models
- *   npm run command -- codex-models
- */
 import { ensureGitignore, formatThinkingForDisplay, DEFAULT_RUN_TIMEOUT_S } from '../bot/bot.js';
 import { initializeProjectSkills, listAgents, listModels, listSkills, getUsage, doStream } from '../agent/index.js';
 import { querySessions, querySessionTail } from '../bot/session-hub.js';
@@ -57,7 +49,6 @@ function parseArgs(argv) {
         }
     }
     args.command = positional[0] ?? null;
-    // If no -p flag, treat remaining positional args as the prompt
     if (!args.prompt && positional.length > 1)
         args.prompt = positional.slice(1).join(' ');
     return args;
@@ -227,7 +218,6 @@ async function main() {
                     ? 'gemini'
                     : 'claude';
             let sessionId = args.session;
-            // Default: find the latest session
             if (!sessionId) {
                 const sessions = await querySessions({ agent, workdir, limit: 1 });
                 if (!sessions.ok || !sessions.sessions.length) {
@@ -278,7 +268,6 @@ async function main() {
             };
             process.stdout.write(`Running ${agent}${args.model ? ` (model: ${args.model})` : ''}...\n`);
             const result = await doStream(opts);
-            // Clear the streaming line and print final result
             process.stdout.write('\r\x1b[K');
             process.stdout.write(`--- ${agent} result ---\n`);
             process.stdout.write(`ok:        ${result.ok}\n`);

package/dist/cli/setup-wizard.js

@@ -1,6 +1,3 @@
-/**
- * Interactive terminal setup wizard.
- */
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
 import { buildSetupGuide, collectSetupState } from './onboarding.js';

package/dist/core/config/runtime-config.js

@@ -1,6 +1,3 @@
-/**
- * Runtime resolution of agent model and effort preferences.
- */
 import { normalizeClaudeModelId } from '../../agent/index.js';
 export const DEFAULT_AGENT_MODELS = {
     claude: 'claude-opus-4-8',
@@ -17,7 +14,6 @@ export const DEFAULT_AGENT_EFFORTS = {
 function trimmed(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
-/** Parse a boolean-ish string (env var / loose config). Empty → null (unset). */
 function parseBoolish(value) {
     const v = value.trim().toLowerCase();
     if (!v)
@@ -85,17 +81,6 @@ export function resolveAgentEffort(config, agent) {
     }
     return null;
 }
-// ---------------------------------------------------------------------------
-// Workflow (multi-agent orchestration) toggle
-//
-// Orthogonal to effort: effort tunes how deeply a *single* agent reasons;
-// workflow grants the agent permission to author + run multi-agent Workflow
-// orchestrations (fan-out / pipeline / verify). Only agents whose driver
-// advertises `capabilities.workflow` honor it (claude today). Default OFF —
-// the claude driver hard-disables the Workflow tool unless this is true, so a
-// bare "workflow" keyword can never auto-spawn a fleet of sub-agents under the
-// bypassPermissions mode pikiloom runs by default.
-// ---------------------------------------------------------------------------
 export function agentWorkflowEnv(agent, env = process.env) {
     switch (agent) {
         case 'claude': return trimmed(env.CLAUDE_WORKFLOW);
@@ -121,16 +106,7 @@ export function setAgentWorkflowEnv(agent, value, env = process.env) {
             break;
     }
 }
-// Default `api` = headless `claude -p`, the standard integration path. The
-// interactive TUI ('subscription', Pro/Max quota) is opt-in via the dashboard
-// 接入模式 toggle or PIKILOOM_CLAUDE_TUI=1.
 export const DEFAULT_CLAUDE_ACCESS_MODE = 'api';
-/**
- * Access mode implied by env, or null when neither var has an opinion.
- * PIKILOOM_CLAUDE_PRINT takes precedence over the legacy PIKILOOM_CLAUDE_TUI so
- * a freshly-written print var resolves a stale tui var (setClaudeAccessModeEnv
- * relies on this). Mirrors isClaudePrintModeForced() in the claude driver.
- */
 export function claudeAccessModeEnv(env = process.env) {
     const print = parseBoolish(trimmed(env.PIKILOOM_CLAUDE_PRINT));
     if (print != null)
@@ -146,8 +122,6 @@ export function resolveClaudeAccessMode(config) {
         return raw;
     return claudeAccessModeEnv() ?? DEFAULT_CLAUDE_ACCESS_MODE;
 }
-/** Mirror the choice into PIKILOOM_CLAUDE_PRINT so any env-only fallback path
- *  (and tooling that inspects the env) agrees with the persisted config. */
 export function setClaudeAccessModeEnv(value, env = process.env) {
     env.PIKILOOM_CLAUDE_PRINT = value === 'api' ? '1' : '0';
 }
@@ -183,18 +157,6 @@ export function setAgentEffortEnv(agent, value, env = process.env) {
             break;
     }
 }
-// ---------------------------------------------------------------------------
-// "Ultra" effort rung — the single user-facing knob that folds workflow in
-//
-// Surfaced as the top rung of every effort picker (IM /models + dashboard),
-// "ultra" means "max reasoning depth + permit multi-agent Workflow
-// orchestration" — the same bundle as Claude's native `ultracode` mode. It is
-// NOT a real --effort value (the CLI hard-rejects anything outside
-// low|medium|high|xhigh|max), so every effort-write path decomposes it into a
-// concrete effort plus the orthogonal workflow flag via this single helper.
-// Because the rungs are mutually exclusive, picking any concrete level clears
-// the orchestration opt-in. See Bot.switchEffortForChat for the IM mirror.
-// ---------------------------------------------------------------------------
 export const ULTRA_EFFORT = 'ultra';
 export function decomposeEffortSelection(raw) {
     const value = trimmed(raw).toLowerCase();