@hunterzhu/pulse-cli 0.1.10 → 0.2.0

package/dist/bin.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import type { LocalHostOptions } from '@hunterzhu/pulse-server';
+import { type LocalHostOptions } from '@hunterzhu/pulse-server';
 export declare const version: string;
 export interface Parsed {
     command: string;

package/dist/bin.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import { resolve } from 'node:path';
+import { isAbsolute, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createMcpCapabilityPack, createPdfCapabilityPack, createSkillCapabilityPack, createSpreadsheetCapabilityPack } from '@hunterzhu/pulse-server';
 import { ensurePulseUserConfig, expandHome, loadPulseConfig } from './config.js';
 import { runInteractive } from './commands/interactive.js';
 import { runOneShot } from './commands/run.js';
@@ -10,6 +11,10 @@ import { runDoctor } from './commands/doctor.js';
 import { runSessions } from './commands/sessions.js';
 import { runResume } from './commands/resume.js';
 import { runSetup } from './commands/setup.js';
+import { runScheduledCommand } from './commands/scheduled.js';
+import { runServiceCommand } from './commands/service.js';
+import { runTemplateCommand } from './commands/template.js';
+import { runMcpDoctor } from './commands/mcp.js';
 import { isSameModulePath } from './utils/is-main-module.js';
 const packageManifest = createRequire(import.meta.url)('../package.json');
 export const version = packageManifest.version;
@@ -26,6 +31,11 @@ Usage:
   pulse sessions [options]                list saved conversations
   pulse resume <conversation-id> [task]    continue or recover a conversation
   pulse doctor [options]                  check local configuration
+  pulse schedule <add|list|pause|resume|remove|daemon> [options]
+                                          manage recurring tasks (daemon requires read-only or auto approval)
+  pulse service <install|status|start|stop|uninstall>
+  pulse template <list|show|run> [name] [values...]
+  pulse mcp doctor [server-id]
 
 Options:
   --cwd <path>              workspace directory
@@ -36,6 +46,7 @@ Options:
   --max-output-tokens <n>   maximum generated tokens (default 4096)
   --reasoning-effort <x>    low, medium, or high
   --max-turns <n>           maximum ReAct model/tool turns (default 32)
+  --execution-mode <mode>   serial (default) or parallel-read (up to three read-only lanes)
   --auto-compact-percent <n> compact automatically at this percent of the context window (1-90, default 90)
   --format <text|jsonl>     output format
   --resume                  enter the latest saved session
@@ -43,10 +54,12 @@ Options:
   --auto-approve             approve local writes and shell execution on your behalf
   --approval-mode <mode>     read-only, ask, or auto
   --allow-network           enable public web search and fetch tools
+  --no-network              disable network tools even when user config enables them
   --trust-workspace         treat workspace .pulse/config.json as user-trusted
   --system-prompt <text>    custom system instructions
   --system-prompt-file <path> load custom system instructions from file
   --mock-response <text>    deterministic response for local debugging
+  --mock-task-assessment <json> deterministic verifier result for local debugging
   --live                    doctor: make one real provider request
   --no-color                disable terminal styling
   --help, -h                show this help
@@ -91,7 +104,7 @@ export function parse(argv) {
             options[key] = true;
             continue;
         }
-        if (!command && ['run', 'sessions', 'resume', 'doctor', 'setup'].includes(arg)) {
+        if (!command && ['run', 'sessions', 'resume', 'doctor', 'setup', 'schedule', 'service', 'template', 'mcp'].includes(arg)) {
             command = arg;
         }
         else {
@@ -124,6 +137,8 @@ export async function hostOptions(parsed) {
     if (!profile)
         throw new Error(`MODEL_PROVIDER_NOT_FOUND:${providerName}`);
     const model = modelSelection.modelCode;
+    if (modelSelection.pricing && (!/^[A-Z]{3}$/.test(modelSelection.pricing.currency) || !Number.isFinite(modelSelection.pricing.inputPerMillion) || modelSelection.pricing.inputPerMillion < 0 || !Number.isFinite(modelSelection.pricing.outputPerMillion) || modelSelection.pricing.outputPerMillion < 0 || !modelSelection.pricing.version.trim()))
+        throw new Error(`INVALID_MODEL_PRICING:${activeModelName}`);
     const baseURL = profile.baseURL;
     const contextTokens = option(parsed.options, 'context-tokens') ?? process.env.PULSE_CONTEXT_TOKENS;
     const maxOutputTokens = option(parsed.options, 'max-output-tokens') ?? process.env.PULSE_MAX_OUTPUT_TOKENS;
@@ -180,18 +195,86 @@ export async function hostOptions(parsed) {
         if (modelDisplayNames.has(displayName))
             throw new Error(`DUPLICATE_MODEL_DISPLAY_NAME:${displayName}`);
         modelDisplayNames.add(displayName);
-        return [[displayName, { provider: item.provider, model: item.modelCode }]];
+        return [[displayName, {
+                    provider: item.provider,
+                    model: item.modelCode,
+                    ...(item.maxContextTokens === undefined ? {} : { maxContextTokens: item.maxContextTokens }),
+                    ...(item.maxOutputTokens === undefined ? {} : { maxOutputTokens: item.maxOutputTokens }),
+                    ...(item.reasoningEffort === undefined ? {} : { reasoningEffort: item.reasoningEffort }),
+                }]];
     }));
+    const taskRouting = config.taskRouting;
+    for (const [task, models] of Object.entries(taskRouting ?? {})) {
+        if (!Array.isArray(models) || models.length === 0 || models.some((model) => typeof model !== 'string' || !providerModels[model])) {
+            throw new Error(`INVALID_TASK_MODEL_ROUTE:${task}`);
+        }
+        if (new Set(models).size !== models.length)
+            throw new Error(`DUPLICATE_TASK_MODEL_ROUTE_CANDIDATE:${task}`);
+    }
     const cwd = requestedCwd ?? expandHome(config.cwd);
     const dataDir = expandHome(option(parsed.options, 'data-dir') ?? process.env.PULSE_DATA_DIR ?? config.dataDir);
     const mockResponse = option(parsed.options, 'mock-response');
+    const mockTaskAssessment = option(parsed.options, 'mock-task-assessment');
+    let mockTaskAssessments;
+    if (mockTaskAssessment !== undefined) {
+        try {
+            const value = JSON.parse(mockTaskAssessment);
+            if (!Array.isArray(value) || value.length === 0 || value.some((item) => !item || typeof item !== 'object' || Array.isArray(item)))
+                throw new Error('INVALID');
+            mockTaskAssessments = value;
+        }
+        catch {
+            throw new Error('INVALID_MOCK_TASK_ASSESSMENT: expected a non-empty JSON array of assessment objects');
+        }
+    }
     const requestedApprovalMode = option(parsed.options, 'approval-mode') ?? process.env.PULSE_APPROVAL_MODE;
     const approvalMode = requestedApprovalMode === 'read-only' || parsed.options['read-only'] === true
         ? 'read-only'
         : requestedApprovalMode === 'auto' || parsed.options['auto-approve'] === true || process.env.PULSE_AUTO_APPROVE === '1'
             ? 'auto'
             : requestedApprovalMode === 'ask' ? 'ask' : config.approvalMode;
-    const allowNetwork = parsed.options['allow-network'] === true || process.env.PULSE_ALLOW_NETWORK === '1' ? true : config.allowNetwork;
+    const allowNetwork = parsed.options['no-network'] === true ? false : parsed.options['allow-network'] === true || process.env.PULSE_ALLOW_NETWORK === '1' ? true : config.allowNetwork;
+    const executionMode = option(parsed.options, 'execution-mode') ?? process.env.PULSE_EXECUTION_MODE ?? config.executionMode ?? 'serial';
+    if (executionMode !== 'serial' && executionMode !== 'parallel-read')
+        throw new Error('INVALID_EXECUTION_MODE: expected serial or parallel-read');
+    const capabilitySettings = config.capabilities ?? {};
+    const skillRoots = capabilitySettings.trustedSkillRoots ?? [];
+    if (!Array.isArray(skillRoots) || skillRoots.some((root) => typeof root !== 'string' || !isAbsolute(expandHome(root) ?? root)))
+        throw new Error('SKILL_TRUSTED_ROOT_MUST_BE_ABSOLUTE');
+    const enabledCapabilityPacks = capabilitySettings.enabled ?? [];
+    if (!Array.isArray(enabledCapabilityPacks) || enabledCapabilityPacks.some((id) => typeof id !== 'string') || new Set(enabledCapabilityPacks).size !== enabledCapabilityPacks.length)
+        throw new Error('INVALID_ENABLED_CAPABILITY_LIST');
+    const skillNames = capabilitySettings.skills ?? [];
+    if (!Array.isArray(skillNames) || skillNames.some((name) => typeof name !== 'string'))
+        throw new Error('INVALID_SKILL_SELECTION');
+    const capabilityPacks = [createPdfCapabilityPack(), createSpreadsheetCapabilityPack(), createSkillCapabilityPack({ trustedRoots: skillRoots.map((root) => resolve(expandHome(root) ?? root)) })];
+    for (const [id, server] of Object.entries(capabilitySettings.mcpServers ?? {})) {
+        if (!server || typeof server.command !== 'string' || server.command.trim().length === 0 || (server.args !== undefined && (!Array.isArray(server.args) || server.args.some((arg) => typeof arg !== 'string'))))
+            throw new Error(`INVALID_MCP_SERVER_CONFIG:${id}`);
+        if (server.toolPolicies && Object.entries(server.toolPolicies).some(([name, policy]) => !name || !['read', 'write', 'external'].includes(policy)))
+            throw new Error(`INVALID_MCP_TOOL_POLICY:${id}`);
+        const resolvedEnv = { ...(server.env ?? {}) };
+        for (const [childName, sourceName] of Object.entries(server.envFrom ?? {})) {
+            if (!/^[A-Z_][A-Z0-9_]*$/i.test(childName) || !/^[A-Z_][A-Z0-9_]*$/i.test(sourceName))
+                throw new Error(`INVALID_MCP_ENV_REFERENCE:${id}`);
+            const value = process.env[sourceName];
+            if (value === undefined)
+                throw new Error(`MCP_ENVIRONMENT_REQUIRED:${id}:${sourceName}`);
+            resolvedEnv[childName] = value;
+        }
+        capabilityPacks.push(createMcpCapabilityPack(id, {
+            command: server.command,
+            args: server.args ?? [],
+            ...(server.cwd === undefined ? {} : { cwd: resolve(expandHome(server.cwd) ?? server.cwd) }),
+            ...(Object.keys(resolvedEnv).length === 0 ? {} : { env: resolvedEnv }),
+            ...(server.timeoutMs === undefined ? {} : { timeoutMs: server.timeoutMs }),
+            ...(server.toolPolicies === undefined ? {} : { toolPolicies: server.toolPolicies }),
+        }));
+    }
+    for (const id of enabledCapabilityPacks) {
+        if (!capabilityPacks.some((pack) => pack.manifest.id === id))
+            throw new Error(`UNKNOWN_ENABLED_CAPABILITY:${id}`);
+    }
     const rawSystemPrompt = option(parsed.options, 'system-prompt') ?? process.env.PULSE_SYSTEM_PROMPT ?? config.systemPrompt;
     const rawSystemPromptFile = option(parsed.options, 'system-prompt-file') ?? process.env.PULSE_SYSTEM_PROMPT_FILE ?? config.systemPromptFile;
     let systemPrompt = rawSystemPrompt;
@@ -218,13 +301,20 @@ export async function hostOptions(parsed) {
         provider,
         providerProfiles,
         providerModels,
+        modelPricing: Object.fromEntries(Object.values(config.models ?? {}).flatMap((item) => item.pricing ? [[item.displayName, item.pricing]] : [])),
+        ...(taskRouting === undefined ? {} : { taskRouting }),
+        capabilityPacks,
+        enabledCapabilityPacks,
+        capabilityConfig: { skills: skillNames },
         activeProviderCode: providerName,
         activeModel: activeModelName,
         ...(mockResponse === undefined ? {} : { mockResponse }),
+        ...(mockTaskAssessments === undefined ? {} : { mockTaskAssessments }),
         ...(approvalMode === undefined ? {} : { approvalMode }),
         ...(configuredMaxTurns === undefined ? {} : { maxTurns: configuredMaxTurns }),
         ...(configuredAutoCompactPercent === undefined ? {} : { autoCompactPercent: Math.min(90, configuredAutoCompactPercent) }),
         ...(allowNetwork === undefined ? {} : { allowNetwork }),
+        executionMode,
     };
 }
 export async function main() {
@@ -247,6 +337,15 @@ export async function main() {
     if (parsed.command === 'sessions') {
         return runSessions(options, option(parsed.options, 'format') ?? 'text', version);
     }
+    if (parsed.command === 'schedule') {
+        return runScheduledCommand(options, parsed.positionals, parsed.options);
+    }
+    if (parsed.command === 'service')
+        return runServiceCommand(options, parsed.positionals);
+    if (parsed.command === 'mcp' && parsed.positionals[0] === 'doctor')
+        return runMcpDoctor(options, parsed.positionals.slice(1));
+    if (parsed.command === 'template')
+        return runTemplateCommand(options, parsed.positionals, option(parsed.options, 'format') ?? 'text', version);
     if (parsed.command === 'run') {
         const task = parsed.positionals.join(' ').trim();
         if (!task)

package/dist/commands/mcp.d.ts

@@ -0,0 +1,2 @@
+import type { LocalHostOptions } from '@hunterzhu/pulse-server';
+export declare function runMcpDoctor(options: LocalHostOptions, ids: string[]): Promise<number>;

package/dist/commands/mcp.js

@@ -0,0 +1,29 @@
+export async function runMcpDoctor(options, ids) {
+    const selected = options.enabledCapabilityPacks ?? [];
+    const requested = ids[0] ? selected.filter(id => id === ids[0]) : selected.filter(id => options.capabilityPacks?.some(pack => pack.manifest.id === id && pack.manifest.kind === 'mcp'));
+    if (ids[0] && !requested.includes(ids[0]))
+        throw new Error(`MCP_SERVER_NOT_ENABLED:${ids[0]}`);
+    const rows = [];
+    for (const id of requested) {
+        const pack = options.capabilityPacks?.find(item => item.manifest.id === id && item.manifest.kind === 'mcp');
+        if (!pack)
+            continue;
+        let activation;
+        try {
+            activation = await pack.activate({ workspaceRoot: options.cwd ?? process.cwd(), config: options.capabilityConfig ?? {}, signal: new AbortController().signal });
+            rows.push({ id, status: 'connected', tools: activation.tools.map(tool => tool.manifest.name) });
+        }
+        catch (error) {
+            rows.push({ id, status: 'failed', error: error instanceof Error ? error.message.replace(/(API[_-]?KEY|TOKEN|SECRET|PASSWORD)\s*[:=]\s*[^\s,;]+/gi, '$1=[REDACTED]') : 'MCP_CONNECTION_FAILED' });
+        }
+        finally {
+            await activation?.dispose?.();
+        }
+    }
+    if (!rows.length) {
+        process.stdout.write('No enabled MCP servers. Configure capabilities.mcpServers and capabilities.enabled.\n');
+        return 1;
+    }
+    process.stdout.write(`${JSON.stringify({ servers: rows }, null, 2)}\n`);
+    return rows.some(row => row.status !== 'connected') ? 1 : 0;
+}

package/dist/commands/resume.js

@@ -47,12 +47,14 @@ export async function runResume(options, conversationId, task, format = 'text',
             }
         }
         const outcome = await run.outcome();
+        const taskOutcome = await run.taskOutcome();
         if (format === 'jsonl') {
             process.stdout.write(`${JSON.stringify({
                 schemaVersion: 1,
                 type: 'result',
                 runId: run.id,
                 status: outcome.status,
+                taskOutcome: taskOutcome ?? null,
                 text: outcome.text ?? null,
                 error: outcome.error ?? null,
             })}\n`);
@@ -66,7 +68,9 @@ export async function runResume(options, conversationId, task, format = 'text',
         else {
             process.stdout.write(`\n[${outcome.status}]\n`);
         }
-        return outcome.status === 'succeeded' ? 0 : outcome.status === 'cancelled' ? 3 : 1;
+        if (outcome.status === 'cancelled')
+            return 3;
+        return outcome.status === 'succeeded' && (!taskOutcome || taskOutcome.status === 'accepted') ? 0 : 1;
     }
     catch (error) {
         process.stderr.write(`[错误] ${error instanceof Error ? error.message : String(error)}\n`);

package/dist/commands/run.js

@@ -49,12 +49,16 @@ export async function runOneShot(options, task, format = 'text', version = '0.1.
             }
         }
         const outcome = await run.outcome();
+        const taskOutcome = await run.taskOutcome();
+        const usage = await run.usage();
         if (format === 'jsonl') {
             process.stdout.write(`${JSON.stringify({
                 schemaVersion: 1,
                 type: 'result',
                 runId: run.id,
                 status: outcome.status,
+                taskOutcome: taskOutcome ?? null,
+                usage,
                 text: outcome.text ?? null,
                 error: outcome.error ?? null,
             })}\n`);
@@ -68,7 +72,9 @@ export async function runOneShot(options, task, format = 'text', version = '0.1.
         else {
             process.stdout.write(`\n[${outcome.status}]\n`);
         }
-        return outcome.status === 'succeeded' ? 0 : outcome.status === 'cancelled' ? 3 : 1;
+        if (outcome.status === 'cancelled')
+            return 3;
+        return outcome.status === 'succeeded' && (!taskOutcome || taskOutcome.status === 'accepted') ? 0 : 1;
     }
     finally {
         unbindSignals();

package/dist/commands/scheduled.d.ts

@@ -0,0 +1,2 @@
+import { type LocalHostOptions } from '@hunterzhu/pulse-server';
+export declare function runScheduledCommand(options: LocalHostOptions, args: string[], flags: Record<string, string | boolean>): Promise<number>;

package/dist/commands/scheduled.js

@@ -0,0 +1,131 @@
+import { realpath } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { createLocalHost, MAX_SCHEDULED_TASK_INTERVAL_MS, MIN_SCHEDULED_TASK_INTERVAL_MS, ScheduledTaskStore, ScheduledTaskWorker, pulseDataPath } from '@hunterzhu/pulse-server';
+function parseInterval(raw) {
+    if (!raw)
+        throw new Error('SCHEDULE_EVERY_REQUIRED');
+    const match = /^(\d+)(ms|s|m|h|d)$/.exec(raw.trim());
+    if (!match)
+        throw new Error('INVALID_SCHEDULE_INTERVAL: use 30s, 15m, 2h, or 1d');
+    const value = Number(match[1]);
+    const multiplier = match[2] === 'ms' ? 1 : match[2] === 's' ? 1_000 : match[2] === 'm' ? 60_000 : match[2] === 'h' ? 3_600_000 : 86_400_000;
+    const intervalMs = value * multiplier;
+    if (!Number.isSafeInteger(intervalMs) || intervalMs < MIN_SCHEDULED_TASK_INTERVAL_MS || intervalMs > MAX_SCHEDULED_TASK_INTERVAL_MS)
+        throw new Error('SCHEDULE_INTERVAL_OUT_OF_RANGE');
+    return intervalMs;
+}
+function storeFor(options) {
+    return new ScheduledTaskStore(join(resolve(options.dataDir ?? pulseDataPath()), 'scheduled-tasks.json'));
+}
+function output(value, format) {
+    process.stdout.write(format === 'jsonl' ? `${JSON.stringify(value)}\n` : `${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runScheduledCommand(options, args, flags) {
+    const [action, id] = args;
+    if (!action)
+        throw new Error('SCHEDULE_ACTION_REQUIRED');
+    const store = storeFor(options);
+    if (action === 'add') {
+        const name = typeof flags.name === 'string' ? flags.name : undefined;
+        const instruction = args.slice(1).join(' ').trim();
+        if (!instruction)
+            throw new Error('SCHEDULE_TASK_REQUIRED');
+        const task = await store.create({ workspace: await realpath(resolve(options.cwd ?? process.cwd())), name: name ?? instruction.slice(0, 120), instruction, intervalMs: parseInterval(typeof flags.every === 'string' ? flags.every : undefined) });
+        output(task, typeof flags.format === 'string' ? flags.format : 'text');
+        return 0;
+    }
+    if (action === 'list') {
+        output(await store.list(), typeof flags.format === 'string' ? flags.format : 'text');
+        return 0;
+    }
+    if (action === 'recover') {
+        if (!id)
+            throw new Error('SCHEDULE_RECOVER_REQUIRES_ID');
+        if (flags['confirm-stopped'] !== true)
+            throw new Error('SCHEDULE_RECOVER_REQUIRES_CONFIRMATION: stop the worker and child processes, then pass --confirm-stopped');
+        const task = await store.get(id);
+        if (!task?.run?.quarantined)
+            throw new Error(`SCHEDULED_TASK_NOT_QUARANTINED:${id}`);
+        const recovered = await store.recoverQuarantined(id, task.run.id);
+        if (!recovered)
+            throw new Error('SCHEDULED_TASK_RECOVERY_RACE');
+        output(recovered, typeof flags.format === 'string' ? flags.format : 'text');
+        return 0;
+    }
+    if (action === 'pause' || action === 'resume' || action === 'remove') {
+        if (!id)
+            throw new Error(`SCHEDULE_${action.toUpperCase()}_REQUIRES_ID`);
+        const result = action === 'remove' ? await store.remove(id) : await store.pause(id, action === 'pause');
+        if (!result)
+            throw new Error(`SCHEDULED_TASK_NOT_FOUND:${id}`);
+        output(result, typeof flags.format === 'string' ? flags.format : 'text');
+        return 0;
+    }
+    if (action !== 'daemon' && action !== 'run-once')
+        throw new Error(`UNKNOWN_SCHEDULE_ACTION:${action}`);
+    if (options.approvalMode !== 'read-only' && options.approvalMode !== 'auto')
+        throw new Error('SCHEDULED_EXECUTION_REQUIRES_READ_ONLY_OR_AUTO_APPROVAL');
+    const host = createLocalHost(options);
+    await host.init();
+    let currentRun;
+    const worker = new ScheduledTaskWorker(store, async (task, signal) => {
+        if (signal.aborted)
+            throw Object.assign(new Error('SCHEDULED_RUN_ABORTED'), { code: 'SCHEDULED_RUN_ABORTED' });
+        if (!task.workspace)
+            throw new Error('SCHEDULED_TASK_WORKSPACE_REQUIRED: recreate this legacy task');
+        const conversation = await host.createConversation({ cwd: task.workspace, title: `Scheduled: ${task.name}` });
+        const run = await host.sendMessage(conversation.id, { text: task.instruction });
+        currentRun = run;
+        const abort = () => { void run.cancel('SCHEDULED_WORKER_STOPPING').catch(() => { }); };
+        signal.addEventListener('abort', abort, { once: true });
+        if (signal.aborted)
+            abort();
+        try {
+            for await (const _event of run.events) {
+                if (signal.aborted) {
+                    await run.cancel('SCHEDULED_WORKER_STOPPING');
+                    throw Object.assign(new Error('SCHEDULED_RUN_ABORTED'), { code: 'SCHEDULED_RUN_ABORTED' });
+                }
+            }
+            const outcome = await run.outcome();
+            const taskOutcome = await run.taskOutcome();
+            if (signal.aborted)
+                throw new Error('SCHEDULED_RUN_ABORTED');
+            if (outcome.status !== 'succeeded')
+                throw Object.assign(new Error(`RUNTIME_${outcome.status.toUpperCase()}`), { code: `RUNTIME_${outcome.status.toUpperCase()}` });
+            if (taskOutcome?.status !== 'accepted')
+                throw Object.assign(new Error(`TASK_${(taskOutcome?.status ?? 'unverified').toUpperCase()}`), { code: `TASK_${(taskOutcome?.status ?? 'unverified').toUpperCase()}` });
+        }
+        catch (error) {
+            // Runtime cancellation may settle before an uncooperative tool stops.
+            // Keep the durable claim until this worker process has exited.
+            if (signal.aborted)
+                throw Object.assign(new Error('SCHEDULED_TASK_CANCELLATION_UNCONFIRMED'), { code: 'SCHEDULED_TASK_CANCELLATION_UNCONFIRMED', cause: error });
+            throw error;
+        }
+        finally {
+            signal.removeEventListener('abort', abort);
+            if (currentRun === run)
+                currentRun = undefined;
+        }
+    });
+    const controller = new AbortController();
+    const stop = () => { controller.abort(); void currentRun?.cancel('SCHEDULED_WORKER_STOPPING'); };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+    let runOnceSummary;
+    try {
+        if (action === 'run-once') {
+            runOnceSummary = await worker.runOnce(controller.signal);
+            output(runOnceSummary, typeof flags.format === 'string' ? flags.format : 'text');
+        }
+        else
+            await worker.start(controller.signal);
+    }
+    finally {
+        process.removeListener('SIGINT', stop);
+        process.removeListener('SIGTERM', stop);
+        await host.close();
+    }
+    return runOnceSummary && runOnceSummary.failed > 0 ? 1 : 0;
+}

package/dist/commands/service.d.ts

@@ -0,0 +1,2 @@
+import type { LocalHostOptions } from '@hunterzhu/pulse-server';
+export declare function runServiceCommand(options: LocalHostOptions, args: string[]): Promise<number>;

package/dist/commands/service.js

@@ -0,0 +1,81 @@
+import { access, mkdir, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+const serviceId = 'com.hunterzhu.pulse.scheduler';
+function checked(file, args) { const result = spawnSync(file, args, { encoding: 'utf8' }); if (result.status !== 0)
+    throw new Error(`${file} ${args[0]} failed: ${(result.stderr || result.stdout || '').trim()}`); }
+function xml(value) { return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;'); }
+function quoteSystemd(value) { return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('%', '%%')}"`; }
+export async function runServiceCommand(options, args) {
+    const [action] = args;
+    if (!['install', 'status', 'start', 'stop', 'uninstall'].includes(action ?? ''))
+        throw new Error('SERVICE_ACTION_REQUIRED');
+    const platform = process.platform;
+    const home = process.env.PULSE_HOME ?? homedir();
+    const executable = process.execPath;
+    const entry = fileURLToPath(new URL('../bin.js', import.meta.url));
+    const config = process.env.PULSE_CONFIG ?? join(home, '.pulse', 'config.json');
+    const data = options.dataDir ?? process.env.PULSE_DATA_DIR ?? join(home, '.pulse', 'data');
+    const cwd = options.cwd ?? process.cwd();
+    if (action === 'install') {
+        if (!['darwin', 'linux', 'win32'].includes(platform))
+            throw new Error(`SERVICE_PLATFORM_UNSUPPORTED:${platform}`);
+        if (platform === 'darwin') {
+            const directory = join(home, 'Library', 'LaunchAgents');
+            const file = join(directory, `${serviceId}.plist`);
+            await mkdir(directory, { recursive: true });
+            await writeFile(file, `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict><key>Label</key><string>${serviceId}</string><key>ProgramArguments</key><array>${[executable, entry, 'schedule', 'daemon', '--approval-mode', options.approvalMode === 'auto' ? 'auto' : 'read-only'].map(v => `<string>${xml(v)}</string>`).join('')}</array><key>WorkingDirectory</key><string>${xml(cwd)}</string><key>EnvironmentVariables</key><dict><key>PULSE_HOME</key><string>${xml(home)}</string><key>PULSE_CONFIG</key><string>${xml(config)}</string><key>PULSE_DATA_DIR</key><string>${xml(data)}</string></dict><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>ThrottleInterval</key><integer>30</integer><key>StandardOutPath</key><string>${xml(join(data, 'service.log'))}</string><key>StandardErrorPath</key><string>${xml(join(data, 'service.error.log'))}</string></dict></plist>\n`, { mode: 0o600 });
+            await mkdir(data, { recursive: true });
+            checked('launchctl', ['bootstrap', `gui/${process.getuid?.() ?? 0}`, file]);
+        }
+        else if (platform === 'linux') {
+            const directory = join(home, '.config', 'systemd', 'user');
+            const file = join(directory, 'pulse-scheduler.service');
+            await mkdir(directory, { recursive: true });
+            await writeFile(file, `[Unit]\nDescription=Pulse scheduled task worker\n\n[Service]\nType=simple\nWorkingDirectory=${quoteSystemd(cwd)}\nEnvironment=${quoteSystemd(`PULSE_HOME=${home}`)}\nEnvironment=${quoteSystemd(`PULSE_CONFIG=${config}`)}\nEnvironment=${quoteSystemd(`PULSE_DATA_DIR=${data}`)}\nExecStart=${quoteSystemd(executable)} ${quoteSystemd(entry)} schedule daemon --approval-mode ${options.approvalMode === 'auto' ? 'auto' : 'read-only'}\nRestart=on-failure\nRestartSec=30s\n\n[Install]\nWantedBy=default.target\n`, { mode: 0o600 });
+            checked('systemctl', ['--user', 'daemon-reload']);
+            checked('systemctl', ['--user', 'enable', '--now', 'pulse-scheduler.service']);
+        }
+        else {
+            const task = 'Pulse Scheduler';
+            const command = `"${executable}" "${entry}" schedule daemon --approval-mode ${options.approvalMode === 'auto' ? 'auto' : 'read-only'}`;
+            checked('schtasks.exe', ['/Create', '/F', '/SC', 'ONLOGON', '/TN', task, '/TR', command]);
+        }
+        process.stdout.write(`Installed user scheduler service (${platform}); status: pulse service status\n`);
+        return 0;
+    }
+    if (platform === 'darwin') {
+        const file = join(home, 'Library', 'LaunchAgents', `${serviceId}.plist`);
+        if (action === 'status' && await access(file).then(() => false, () => true)) {
+            process.stdout.write('Scheduler service is not installed.\n');
+            return 0;
+        }
+        if (action === 'uninstall') {
+            spawnSync('launchctl', ['bootout', `gui/${process.getuid?.() ?? 0}`, file], { stdio: 'ignore' });
+            await rm(file, { force: true });
+            return 0;
+        }
+        const result = spawnSync('launchctl', [action === 'status' ? 'print' : action === 'start' ? 'kickstart' : 'kill', ...(action === 'start' ? ['-k'] : action === 'stop' ? ['SIGTERM'] : []), `gui/${process.getuid?.() ?? 0}/${serviceId}`], { encoding: 'utf8' });
+        process.stdout.write(result.stdout || result.stderr || `${action}: ${result.status === 0 ? 'ok' : 'not running'}\n`);
+        return result.status === 0 ? 0 : 1;
+    }
+    if (platform === 'linux') {
+        if (action === 'status' && await access(join(home, '.config', 'systemd', 'user', 'pulse-scheduler.service')).then(() => false, () => true)) {
+            process.stdout.write('Scheduler service is not installed.\n');
+            return 0;
+        }
+        const verb = action === 'status' ? 'status' : action === 'start' ? 'start' : action === 'stop' ? 'stop' : 'disable';
+        const result = spawnSync('systemctl', ['--user', verb, ...(action === 'uninstall' ? ['--now'] : []), 'pulse-scheduler.service'], { encoding: 'utf8' });
+        if (action === 'uninstall')
+            await rm(join(home, '.config', 'systemd', 'user', 'pulse-scheduler.service'), { force: true });
+        process.stdout.write(result.stdout || result.stderr || '');
+        return result.status === 0 ? 0 : 1;
+    }
+    const task = 'Pulse Scheduler';
+    const verb = action === 'status' ? '/Query' : action === 'start' ? '/Run' : action === 'stop' ? '/End' : '/Delete';
+    const result = spawnSync('schtasks.exe', [verb, '/TN', task, ...(action === 'uninstall' ? ['/F'] : [])], { encoding: 'utf8' });
+    process.stdout.write(result.stdout || result.stderr || '');
+    return result.status === 0 ? 0 : 1;
+}

package/dist/commands/template.d.ts

@@ -0,0 +1,2 @@
+import type { LocalHostOptions } from '@hunterzhu/pulse-server';
+export declare function runTemplateCommand(options: LocalHostOptions, args: string[], format: string, version: string): Promise<number>;

package/dist/commands/template.js

@@ -0,0 +1,31 @@
+import { runOneShot } from './run.js';
+const templates = [
+    { version: 1, name: 'code-review', description: '审查当前工作区中的代码变更并给出有证据的问题清单。', parameters: ['focus'], deliverables: ['按严重程度排序的 findings', '文件路径与行号'], acceptance: ['每条问题有可复核代码证据', '不把风格偏好列作缺陷'], prompt: '审查当前工作区代码变更。重点：{{focus}}。只报告能从源码证明的问题，按严重度排序，给出路径和行号；若没有发现，说明审查范围和未覆盖部分。' },
+    { version: 1, name: 'research', description: '围绕问题检索资料并整理可追溯结论。', parameters: ['question', 'sources'], deliverables: ['结论摘要', '来源及支持的主张'], acceptance: ['区分事实与推断', '每项关键结论附来源'], prompt: '研究问题：{{question}}。优先使用这些来源范围：{{sources}}。给出结论、证据链接、更新时间和不确定性；无法核验的内容标明未知。' },
+    { version: 1, name: 'file-organization', description: '按规则整理工作区文件，先规划并遵守工具审批。', parameters: ['rules'], deliverables: ['整理后的文件', '移动清单'], acceptance: ['不覆盖已有目标', '总结每次移动'], prompt: '按以下规则整理当前工作区文件：{{rules}}。先检查现状并制定计划，再执行获批的移动；遇到目标冲突时跳过并报告。' },
+    { version: 1, name: 'project-health', description: '检查项目入口、构建、测试和近期变更，报告健康状态。', parameters: ['scope'], deliverables: ['检查结果', '风险与建议'], acceptance: ['运行检查前说明具体命令', '区分已验证和推测'], prompt: '检查项目健康状态，范围：{{scope}}。阅读项目脚本与文档，运行适用的本地只读检查，汇报证据、失败和未覆盖项；不得安装、发布或修改文件。' },
+];
+function render(template, values) {
+    if (values.length !== template.parameters.length)
+        throw new Error(`TEMPLATE_ARGUMENTS_REQUIRED:${template.name}:${template.parameters.join(',')}`);
+    let prompt = template.prompt;
+    template.parameters.forEach((name, index) => { prompt = prompt.replaceAll(`{{${name}}}`, values[index] ?? ''); });
+    return prompt;
+}
+export async function runTemplateCommand(options, args, format, version) {
+    const [action, name, ...values] = args;
+    if (action === 'list') {
+        process.stdout.write(templates.map(item => `${item.name}\t${item.description}`).join('\n') + '\n');
+        return 0;
+    }
+    const template = templates.find(item => item.name === name);
+    if (!template)
+        throw new Error(action === 'run' || action === 'show' ? `TEMPLATE_NOT_FOUND:${name ?? ''}` : 'TEMPLATE_ACTION_REQUIRED');
+    if (action === 'show') {
+        process.stdout.write(`${JSON.stringify(template, null, 2)}\n`);
+        return 0;
+    }
+    if (action !== 'run')
+        throw new Error('TEMPLATE_ACTION_REQUIRED');
+    return runOneShot(options, render(template, values), format, version);
+}

package/dist/components/App.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect, useCallback, useRef } from 'react';
-import { Box, Text, useApp, useInput } from 'ink';
+import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import { Header } from './Header.js';
 import { Welcome } from './Welcome.js';
 import { MessageList } from './MessageList.js';
@@ -18,7 +18,11 @@ import { useTokenStats } from '../hooks/useTokenStats.js';
 import { useSlashCommands } from '../hooks/useSlashCommands.js';
 export function App({ hostOptions, conversationId: initialConversationId, initialTask, resumeOnStart = false, version, }) {
     const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [terminalRows, setTerminalRows] = useState(stdout.rows || 24);
+    useEffect(() => { const resize = () => setTerminalRows(stdout.rows || 24); stdout.on('resize', resize); return () => { stdout.off('resize', resize); }; }, [stdout]);
     const [mode, setMode] = useState('chat');
+    const [mouseEnabled, setMouseEnabled] = useState(true);
     const [showThinking, setShowThinking] = useState(false);
     const [verbosity, setVerbosity] = useState('normal');
     const [sessionsList, setSessionsList] = useState([]);
@@ -95,6 +99,7 @@ export function App({ hostOptions, conversationId: initialConversationId, initia
         })();
     }, [hostReady, conversation, initialTask, isRunning, addUserMessage, addAssistantMessage, createConversation, sendMessage]);
     const { executeCommand, isSlashCommand } = useSlashCommands({
+        onMouse: (arg) => setMouseEnabled((current) => arg === 'off' ? false : arg === 'on' ? true : !current),
         onHelp: () => setMode('help'),
         onSessions: async () => {
             await loadSessions();
@@ -480,7 +485,7 @@ export function App({ hostOptions, conversationId: initialConversationId, initia
     const title = conversation?.summary.title ?? 'New conversation';
     const modelName = host?.getModel() || hostOptions.provider?.defaultModel || hostOptions.provider?.provider || 'default';
     const providerName = host?.getProvider() || hostOptions.activeProviderCode || hostOptions.provider?.provider || 'default';
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: "100%", children: [_jsx(Header, { title: title, cwd: cwd, model: modelName, approvalMode: hostOptions.approvalMode ?? 'ask' }), messages.length === 0 && !isRunning && (_jsx(Welcome, { cwd: cwd, model: modelName, version: version })), messages.length > 0 && (_jsx(MessageList, { messages: messages, showThinking: showThinking, verbosity: verbosity, isRunning: isRunning })), isRunning && !approvalRequest && !askRequest && (_jsx(Box, { marginY: 1, children: _jsx(Spinner, { label: currentStep || '正在思考与执行...' }) })), runError && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: "red", children: ["\u9519\u8BEF: ", runError] }) })), conversationError && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: "red", children: ["\u4F1A\u8BDD\u6D88\u606F\u52A0\u8F7D\u5931\u8D25: ", conversationError] }) })), _jsx(StatusHud, { cwd: cwd, model: modelName, provider: providerName, approvalMode: hostOptions.approvalMode ?? 'ask', currentStep: currentStep, lanes: lanes }), approvalRequest ? (_jsx(ApprovalPrompt, { request: approvalRequest, inputMode: approvalInputMode, isFocused: approvalChoiceFocused && !approvalSubmitting, onApprove: () => {
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: terminalRows, children: [_jsx(Header, { title: title, cwd: cwd, model: modelName, approvalMode: hostOptions.approvalMode ?? 'ask' }), messages.length === 0 && !isRunning && (_jsx(Welcome, { cwd: cwd, model: modelName, version: version })), messages.length > 0 && (_jsx(MessageList, { mouseEnabled: mouseEnabled, messages: messages, showThinking: showThinking, verbosity: verbosity, isRunning: isRunning })), runError && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: "red", children: ["\u9519\u8BEF: ", runError] }) })), conversationError && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: "red", children: ["\u4F1A\u8BDD\u6D88\u606F\u52A0\u8F7D\u5931\u8D25: ", conversationError] }) })), _jsx(StatusHud, { isRunning: isRunning, cwd: cwd, model: modelName, provider: providerName, approvalMode: hostOptions.approvalMode ?? 'ask', currentStep: currentStep, lanes: lanes }), approvalRequest ? (_jsx(ApprovalPrompt, { request: approvalRequest, inputMode: approvalInputMode, isFocused: approvalChoiceFocused && !approvalSubmitting, onApprove: () => {
                     void approveAction(approvalRequest.effectId, true);
                 }, onDeny: (reason) => {
                     void approveAction(approvalRequest.effectId, false, reason);

package/dist/components/AskPrompt.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text, useInput } from 'ink';
-import TextInput from 'ink-text-input';
+import TextInput from './TextInput.js';
 import { useState } from 'react';
 import { theme } from '../theme.js';
 export function AskPrompt({ request, disabled = false, onReply }) {

package/dist/components/Header.d.ts

@@ -4,5 +4,5 @@ interface Props {
     model: string;
     approvalMode?: 'read-only' | 'ask' | 'auto' | undefined;
 }
-export declare function Header({ title, cwd, model, approvalMode }: Props): import("react").JSX.Element;
+export declare function Header({ title, cwd, model }: Props): import("react").JSX.Element;
 export {};

package/dist/components/Header.js

@@ -2,8 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { theme } from '../theme.js';
 import path from 'node:path';
-export function Header({ title, cwd, model, approvalMode = 'ask' }) {
+export function Header({ title, cwd, model }) {
     const cwdBasename = path.basename(cwd);
-    const approvalLabel = approvalMode === 'auto' ? 'AUTO' : approvalMode === 'read-only' ? 'READ-ONLY' : 'ASK';
-    return (_jsxs(Box, { borderBottom: true, borderStyle: "single", borderColor: theme.border, borderTop: false, borderLeft: false, borderRight: false, width: "100%", justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: theme.primary, bold: true, children: " PULSE " }), _jsx(Text, { color: "white", bold: true, children: title })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: theme.dim, children: cwdBasename }), _jsx(Text, { color: theme.dim, children: "\u00B7" }), _jsx(Text, { color: theme.dim, children: model }), _jsx(Text, { color: approvalMode === 'auto' ? theme.warning : theme.dim, children: approvalLabel })] })] }));
+    return (_jsxs(Box, { borderBottom: true, borderStyle: "single", borderColor: theme.border, borderTop: false, borderLeft: false, borderRight: false, width: "100%", flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Text, { color: theme.primary, bold: true, children: " PULSE " }), _jsx(Text, { color: "white", wrap: "truncate-end", children: title.length > 36 ? `${title.slice(0, 36)}…` : title })] }), _jsxs(Box, { gap: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Text, { color: theme.dim, wrap: "truncate-end", children: cwdBasename }), _jsx(Text, { color: theme.dim, children: "\u00B7" }), _jsx(Text, { color: theme.dim, wrap: "truncate-end", children: model })] })] }));
 }

package/dist/components/HelpView.js

@@ -5,6 +5,7 @@ const COMMANDS = [
     {
         category: 'General',
         commands: [
+            { name: '/mouse on|off', desc: '开关滚轮/触控板滚动；关闭后可原生选择文本' },
             { name: '/help', desc: '显示帮助信息' },
             { name: '/status', desc: '查看会话状态' },
             { name: '/tools', desc: '列出可用工具' },
@@ -41,5 +42,5 @@ const COMMANDS = [
     },
 ];
 export function HelpView() {
-    return (_jsx(Box, { flexDirection: "column", marginY: 1, children: COMMANDS.map((section, idx) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.primary, bold: true, children: section.category }), section.commands.map((cmd, cIdx) => (_jsxs(Box, { children: [_jsx(Box, { width: 28, children: _jsx(Text, { color: theme.accent, children: cmd.name }) }), _jsx(Text, { children: cmd.desc })] }, cIdx)))] }, idx))) }));
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { children: "\u6EDA\u8F6E / \u89E6\u63A7\u677F\u53CC\u6307\u6EDA\u52A8 \u00B7 Ctrl+P / Ctrl+N \u7FFB\u9875 \u00B7 Ctrl+G \u56DE\u5230\u5E95\u90E8\uFF08\u4E5F\u652F\u6301 Fn+\u2191 / Fn+\u2193\uFF09" }), COMMANDS.map((section, idx) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: theme.primary, bold: true, children: section.category }), section.commands.map((cmd, cIdx) => (_jsxs(Box, { children: [_jsx(Box, { width: 28, children: _jsx(Text, { color: theme.accent, children: cmd.name }) }), _jsx(Text, { children: cmd.desc })] }, cIdx)))] }, idx)))] }));
 }

package/dist/components/InputArea.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text, useInput } from 'ink';
-import TextInput from 'ink-text-input';
+import TextInput from './TextInput.js';
 import { useState } from 'react';
 import { theme } from '../theme.js';
 export function InputArea({ onSubmit, disabled, focus = true, placeholder }) {
@@ -11,6 +11,8 @@ export function InputArea({ onSubmit, disabled, focus = true, placeholder }) {
     useInput((input, key) => {
         if (disabled || !focus)
             return;
+        if (key.ctrl || key.meta || key.pageUp || key.pageDown)
+            return;
         if (key.return) {
             if (key.shift) {
                 setAccumulatedLines((current) => [...current, value]);

package/dist/components/MessageList.d.ts

@@ -1,9 +1,10 @@
 import type { DisplayMessage, Verbosity } from '../types.js';
 interface Props {
+    mouseEnabled?: boolean;
     messages: DisplayMessage[];
     showThinking?: boolean | undefined;
     verbosity?: Verbosity | undefined;
     isRunning?: boolean | undefined;
 }
-export declare function MessageList({ messages, showThinking, verbosity, isRunning }: Props): import("react").JSX.Element;
+export declare function MessageList({ mouseEnabled, messages, showThinking, verbosity, isRunning }: Props): import("react").JSX.Element;
 export {};

package/dist/components/MessageList.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { MessageViewport } from './MessageViewport.js';
-export function MessageList({ messages, showThinking, verbosity = 'normal', isRunning = false }) {
-    return _jsx(MessageViewport, { messages: messages, ...(showThinking === undefined ? {} : { showThinking }), verbosity: verbosity, isRunning: isRunning });
+export function MessageList({ mouseEnabled = true, messages, showThinking, verbosity = 'normal', isRunning = false }) {
+    return _jsx(MessageViewport, { mouseEnabled: mouseEnabled, messages: messages, ...(showThinking === undefined ? {} : { showThinking }), verbosity: verbosity, isRunning: isRunning });
 }

package/dist/components/MessageViewport.d.ts

@@ -1,14 +1,10 @@
 import type { DisplayMessage, Verbosity } from '../types.js';
 interface Props {
+    mouseEnabled?: boolean;
     messages: DisplayMessage[];
     showThinking?: boolean;
     verbosity?: Verbosity;
     isRunning?: boolean;
 }
-/**
- * A bounded message window. Ink has no built-in scroll viewport, so only the
- * visible message window is reconciled. This keeps streaming output from
- * re-rendering the whole transcript and leaves the header/HUD/input stable.
- */
-export declare function MessageViewport({ messages, showThinking, verbosity, isRunning }: Props): import("react").JSX.Element;
+export declare function MessageViewport({ messages, verbosity, mouseEnabled }: Props): import("react").JSX.Element;
 export {};

package/dist/components/MessageViewport.js

@@ -1,77 +1,50 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text, useInput, useStdout } from 'ink';
-import { useEffect, useMemo, useState } from 'react';
+import { Box, Text, useInput, useStdout, measureElement } from 'ink';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { mouseEvent, enableMouse, disableMouse } from '../utils/mouse.js';
 import { theme } from '../theme.js';
-import { AssistantMessage } from './AssistantMessage.js';
-import { UserMessage } from './UserMessage.js';
-import { stripTerminalControls } from '../utils/ansi.js';
-const minimumViewportRows = 5;
-function messageWeight(message, width) {
-    const contentWidth = Math.max(24, width - 8);
-    const text = stripTerminalControls(message.text || message.thinking || '');
-    const textRows = text.split('\n').reduce((total, line) => total + Math.max(1, Math.ceil(line.length / contentWidth)), 0);
-    const toolRows = message.toolCalls?.length ? message.toolCalls.length + 1 : 0;
-    return Math.max(2, textRows + toolRows + (message.role === 'system' ? 1 : 2));
-}
-function renderMessage(message, showThinking, verbosity, isLast) {
-    return (_jsxs(Box, { flexDirection: "column", children: [message.role === 'user' && _jsx(UserMessage, { text: message.text, timestamp: message.createdAt }), message.role === 'assistant' && (_jsx(AssistantMessage, { text: message.text, thinking: message.thinking, showThinking: showThinking, verbosity: verbosity, toolCalls: message.toolCalls, tokenStats: message.tokenStats })), message.role === 'system' && (_jsx(Box, { paddingX: 1, marginY: 1, children: _jsx(Text, { color: theme.dim, italic: true, children: stripTerminalControls(message.text) }) })), !isLast && _jsx(Box, { height: 1 })] }, message.id));
-}
-/**
- * A bounded message window. Ink has no built-in scroll viewport, so only the
- * visible message window is reconciled. This keeps streaming output from
- * re-rendering the whole transcript and leaves the header/HUD/input stable.
- */
-export function MessageViewport({ messages, showThinking = false, verbosity = 'normal', isRunning = false }) {
+import { transcriptLines, scrollAction } from '../utils/transcript.js';
+export function MessageViewport({ messages, verbosity = 'normal', mouseEnabled = true }) {
     const { stdout } = useStdout();
-    const [rows, setRows] = useState(stdout.rows || 24);
-    const [scrollOffset, setScrollOffset] = useState(0);
-    useEffect(() => {
-        const onResize = () => setRows(stdout.rows || 24);
-        stdout.on('resize', onResize);
-        return () => {
-            stdout.off('resize', onResize);
-        };
-    }, [stdout]);
-    const viewportRows = Math.max(minimumViewportRows, rows - (isRunning ? 9 : 7));
-    const width = stdout.columns || 100;
-    const weights = useMemo(() => messages.map((message) => messageWeight(message, width)), [messages, width]);
-    const totalRows = weights.reduce((sum, weight) => sum + weight, 0);
-    const maxScroll = Math.max(0, totalRows - viewportRows);
     useEffect(() => {
-        if (isRunning)
-            setScrollOffset(0);
-        else
-            setScrollOffset((current) => Math.min(current, maxScroll));
-    }, [isRunning, maxScroll, messages.length]);
-    useInput((_input, key) => {
-        if (key.pageUp) {
-            setScrollOffset((current) => Math.min(maxScroll, current + Math.max(1, viewportRows - 2)));
-        }
-        else if (key.pageDown) {
-            setScrollOffset((current) => Math.max(0, current - Math.max(1, viewportRows - 2)));
-        }
-        else if (key.home) {
-            setScrollOffset(maxScroll);
+        if (!mouseEnabled || !stdout.isTTY)
+            return;
+        stdout.write(enableMouse);
+        return () => { stdout.write(disableMouse); };
+    }, [mouseEnabled, stdout]);
+    const box = useRef(null);
+    const [size, setSize] = useState({ width: stdout.columns || 80, height: 12 });
+    const [start, setStart] = useState(null);
+    useLayoutEffect(() => {
+        if (!box.current)
+            return;
+        const measured = measureElement(box.current);
+        setSize((previous) => previous.width === measured.width && previous.height === measured.height ? previous : measured);
+    });
+    useEffect(() => { const resize = () => setSize((s) => ({ ...s, width: stdout.columns || 80 })); stdout.on('resize', resize); return () => { stdout.off('resize', resize); }; }, [stdout]);
+    const lines = useMemo(() => transcriptLines(messages, size.width, verbosity), [messages, size.width, verbosity]);
+    const page = Math.max(1, size.height - 1);
+    const bottom = Math.max(0, lines.length - page);
+    const first = start === null ? bottom : Math.min(start, bottom);
+    useInput((input, key) => {
+        const mouse = mouseEvent(input);
+        if (mouse) {
+            if (mouseEnabled && mouse.wheel)
+                setStart((previous) => {
+                    const next = Math.max(0, Math.min(bottom, (previous === null ? bottom : Math.min(previous, bottom)) + mouse.wheel));
+                    return next === bottom ? null : next;
+                });
+            return;
         }
-        else if (key.end) {
-            setScrollOffset(0);
+        const action = scrollAction(input, key);
+        if (action === 'up')
+            setStart(Math.max(0, first - Math.max(1, page - 2)));
+        if (action === 'down') {
+            const next = Math.min(bottom, first + Math.max(1, page - 2));
+            setStart(next === bottom ? null : next);
         }
+        if (action === 'bottom')
+            setStart(null);
     });
-    // scrollOffset is measured from the newest message: 0 means follow the
-    // bottom, maxScroll means show the oldest visible window.
-    let remaining = Math.max(0, totalRows - viewportRows - scrollOffset);
-    let startIndex = 0;
-    while (startIndex < weights.length && remaining >= weights[startIndex]) {
-        remaining -= weights[startIndex];
-        startIndex++;
-    }
-    let visibleRows = 0;
-    let endIndex = startIndex;
-    while (endIndex < messages.length && visibleRows < viewportRows + 1) {
-        visibleRows += weights[endIndex];
-        endIndex++;
-    }
-    const visibleMessages = messages.slice(startIndex, endIndex);
-    const isAtBottom = scrollOffset === 0;
-    return (_jsxs(Box, { flexDirection: "column", height: viewportRows, overflow: "hidden", children: [!isAtBottom && _jsx(Text, { color: theme.dim, children: "\u2191 PageUp \u67E5\u770B\u66F4\u65E9\u6D88\u606F \u00B7 PageDown \u8FD4\u56DE\u6700\u65B0" }), visibleMessages.length === 0 ? (_jsx(Box, { flexGrow: 1 })) : (visibleMessages.map((message, index) => renderMessage(message, showThinking, verbosity, startIndex + index === messages.length - 1))), maxScroll > 0 && isAtBottom && _jsx(Text, { color: theme.dim, children: "\u2193 \u5DF2\u5728\u6700\u65B0\u6D88\u606F \u00B7 PageUp \u6EDA\u52A8\u5386\u53F2" })] }));
+    return (_jsxs(Box, { ref: box, flexDirection: "column", flexGrow: 1, flexShrink: 1, flexBasis: 0, minHeight: 3, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", height: page, overflow: "hidden", children: _jsx(Text, { children: lines.slice(first, first + page).join('\n') }) }), _jsx(Text, { color: theme.dim, children: start === null ? (mouseEnabled ? '滚轮 / 双指滚动 · Ctrl+G 回到底部' : 'Ctrl+P 上翻 · Ctrl+N 下翻') : `历史 ${first + 1}–${Math.min(lines.length, first + page)}/${lines.length} · 滚动浏览 · Ctrl+G 回到底部` })] }));
 }

package/dist/components/StatusHud.d.ts

@@ -1,5 +1,6 @@
 import type { LaneDisplay } from '../types.js';
 interface Props {
+    isRunning?: boolean;
     cwd: string;
     model: string;
     provider: string;
@@ -7,5 +8,5 @@ interface Props {
     currentStep?: string | null;
     lanes: LaneDisplay[];
 }
-export declare function StatusHud({ cwd, model, provider, approvalMode, currentStep, lanes }: Props): import("react").JSX.Element;
+export declare function StatusHud({ isRunning, approvalMode, currentStep, lanes }: Props): import("react").JSX.Element;
 export {};

package/dist/components/StatusHud.js

@@ -1,12 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { Spinner } from './Spinner.js';
 import { theme } from '../theme.js';
-function laneLabel(lane) {
-    const goal = lane.goal.length > 34 ? `${lane.goal.slice(0, 34)}…` : lane.goal;
-    return `${lane.id.slice(0, 8)} ${lane.status}${lane.activity ? ` · ${lane.activity}` : ''}${goal ? ` · ${goal}` : ''}`;
-}
-export function StatusHud({ cwd, model, provider, approvalMode, currentStep, lanes }) {
-    const activeLanes = lanes.filter((lane) => !['succeeded', 'failed', 'cancelled'].includes(lane.status));
-    const approvalLabel = approvalMode === 'auto' ? 'auto' : approvalMode === 'read-only' ? '只读' : 'ask';
-    return (_jsxs(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: theme.border, flexDirection: "column", paddingTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: theme.primary, bold: true, children: "STATUS" }), _jsxs(Text, { color: theme.dim, children: ["model:", model] }), _jsxs(Text, { color: theme.dim, children: ["provider:", provider] }), _jsxs(Text, { color: approvalMode === 'auto' ? theme.warning : theme.dim, children: ["approval:", approvalLabel] }), _jsxs(Text, { color: activeLanes.length ? theme.accent : theme.dim, children: ["lanes:", activeLanes.length, "/", lanes.length] }), currentStep && _jsxs(Text, { color: theme.dim, children: ["\u00B7 ", currentStep] })] }), _jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: theme.dim, children: ["workspace:", cwd] }) }), lanes.length > 0 && (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: lanes.slice(-4).map((lane) => (_jsx(Text, { color: lane.status === 'failed' ? theme.error : lane.status === 'succeeded' ? theme.success : theme.dim, children: laneLabel(lane) }, lane.id))) }))] }));
+export function StatusHud({ isRunning, approvalMode, currentStep, lanes }) {
+    const active = lanes.filter((lane) => !['succeeded', 'failed', 'cancelled'].includes(lane.status));
+    return _jsxs(Box, { flexShrink: 0, gap: 1, children: [isRunning && _jsx(Spinner, {}), _jsxs(Text, { color: theme.dim, wrap: "truncate-end", children: [isRunning ? currentStep || '正在执行' : '就绪', " \u00B7 ", approvalMode === 'auto' ? '自动审批' : approvalMode === 'read-only' ? '只读' : '操作前询问', active.length > 1 ? ` · ${active.length} 个子任务` : '', " \u00B7 /help \u5E2E\u52A9 \u00B7 /verbose \u8BE6\u60C5"] })] });
 }

package/dist/components/TextInput.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    value: string;
+    onChange: (value: string) => void;
+    focus?: boolean;
+    placeholder?: string;
+}
+/** Keep global control shortcuts out of editable text, including on Mac terminals. */
+export default function TextInput({ value, onChange, focus, placeholder }: Props): import("react").JSX.Element;
+export {};

package/dist/components/TextInput.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import { useRef, useState } from 'react';
+import { mouseEvent } from '../utils/mouse.js';
+import { stripTerminalControls } from '../utils/ansi.js';
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** Keep global control shortcuts out of editable text, including on Mac terminals. */
+export default function TextInput({ value, onChange, focus = true, placeholder = '' }) {
+    const [position, setPosition] = useState(null);
+    const editing = useRef({ value, position });
+    editing.current = { value, position };
+    const characters = Array.from(segmenter.segment(value), (part) => part.segment);
+    const cursor = position === null ? characters.length : Math.min(position, characters.length);
+    useInput((input, key) => {
+        const characters = Array.from(segmenter.segment(editing.current.value), (part) => part.segment);
+        const cursor = editing.current.position === null ? characters.length : Math.min(editing.current.position, characters.length);
+        const move = (next) => { editing.current.position = next; setPosition(next); };
+        if (mouseEvent(input))
+            return;
+        if (key.ctrl || key.meta || key.pageUp || key.pageDown || key.upArrow || key.downArrow || key.tab || key.escape || key.return)
+            return;
+        if (key.leftArrow || key.rightArrow || key.home || key.end) {
+            move(key.home ? 0 : key.end ? null : Math.max(0, Math.min(characters.length, cursor + (key.leftArrow ? -1 : 1))));
+            return;
+        }
+        const next = [...characters];
+        if (key.backspace || key.delete) {
+            if (!cursor)
+                return;
+            next.splice(cursor - 1, 1);
+            move(cursor - 1 === next.length ? null : cursor - 1);
+        }
+        else {
+            const inserted = Array.from(segmenter.segment(stripTerminalControls(input)), (part) => part.segment);
+            if (!inserted.length)
+                return;
+            next.splice(cursor, 0, ...inserted);
+            move(cursor === characters.length ? null : cursor + inserted.length);
+        }
+        editing.current.value = next.join('');
+        onChange(editing.current.value);
+    }, { isActive: focus });
+    if (!value)
+        return _jsxs(Text, { dimColor: true, children: [focus ? _jsx(Text, { inverse: true, children: placeholder.slice(0, 1) || ' ' }) : null, focus ? placeholder.slice(1) : placeholder] });
+    return _jsxs(Text, { children: [characters.slice(0, cursor).join(''), focus ? _jsx(Text, { inverse: true, children: characters[cursor] || ' ' }) : characters[cursor], characters.slice(cursor + 1).join('')] });
+}

package/dist/config.d.ts

@@ -24,6 +24,35 @@ export interface PulseCliModel {
     maxContextTokens?: number;
     maxOutputTokens?: number;
     reasoningEffort?: 'low' | 'medium' | 'high';
+    pricing?: {
+        currency: string;
+        inputPerMillion: number;
+        outputPerMillion: number;
+        version: string;
+    };
+}
+export type PulseModelTask = 'reason' | 'plan' | 'merge' | 'verify';
+export interface PulseCliMcpServer {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    /** Explicit environment overrides; secret values should be sourced through provider-specific env mechanisms where possible. */
+    env?: Record<string, string>;
+    /** Map child environment names to names of variables in Pulse's launch environment. */
+    envFrom?: Record<string, string>;
+    timeoutMs?: number;
+    /** Explicit trust decision for each remote tool; all unspecified tools remain external. */
+    toolPolicies?: Record<string, 'read' | 'write' | 'external'>;
+}
+export interface PulseCliCapabilities {
+    /** IDs must be explicitly enabled; workspace config cannot enable host extensions. */
+    enabled?: string[];
+    /** Names of host-installed skills to load as untrusted instructions. */
+    skills?: string[];
+    /** Additional absolute roots explicitly trusted by the user for installed skills. */
+    trustedSkillRoots?: string[];
+    /** Host-level MCP processes; these are executable trusted configuration. */
+    mcpServers?: Record<string, PulseCliMcpServer>;
 }
 export interface PulseCliConfig {
     cwd?: string;
@@ -36,7 +65,12 @@ export interface PulseCliConfig {
     models?: Record<string, PulseCliModel>;
     /** Active Pulse model display name. */
     activeModel?: string;
+    /** Ordered model display names per task; later entries act as fallbacks. */
+    taskRouting?: Partial<Record<PulseModelTask, string[]>>;
+    capabilities?: PulseCliCapabilities;
     approvalMode?: 'read-only' | 'ask' | 'auto';
+    /** Parallelism is opt-in and only exposes tools explicitly classified read-only. */
+    executionMode?: 'serial' | 'parallel-read';
     maxTurns?: number;
     /** Percent of maxContextTokens that triggers automatic history compaction. Clamped to 1–90. */
     autoCompactPercent?: number;

package/dist/config.js

@@ -24,6 +24,7 @@ export const defaultPulseConfig = {
     },
     activeModel: 'mock',
     approvalMode: 'ask',
+    executionMode: 'serial',
     maxTurns: 32,
     autoCompactPercent: 90,
     allowNetwork: false,
@@ -81,8 +82,11 @@ export function sanitizeWorkspaceConfig(value) {
     return {
         ...(value.cwd === undefined ? {} : { cwd: value.cwd }),
         ...(value.dataDir === undefined ? {} : { dataDir: value.dataDir }),
+        // Workspace configs cannot launch processes, select host skills, or enable installed capabilities.
         ...(providers === undefined || Object.keys(providers).length === 0 ? {} : { providers }),
         ...(value.activeModel === undefined ? {} : { activeModel: value.activeModel }),
+        // Workspace configs may select a model, but routing affects provider and
+        // data-sharing choices and therefore remains user-config-only.
         ...(value.models === undefined ? {} : {
             models: Object.fromEntries(Object.entries(value.models).flatMap(([name, model]) => {
                 if (!model.provider || !model.modelCode)

package/dist/hooks/useRun.js

@@ -184,7 +184,9 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                             break;
                         }
                     }
-                    setCurrentStep(describeFactStatus(event.data));
+                    // Runtime facts are diagnostic data, not user-facing prose.
+                    if (typeof event.data === 'string' && event.data.startsWith('human.input.'))
+                        setCurrentStep(describeFactStatus(event.data));
                     break;
                 case 'error':
                     setError(String(event.data ?? '发生未知错误'));
@@ -201,6 +203,36 @@ export function useRun({ host, conversationId, addAssistantMessage, }) {
                     setAskRequest(null);
                     if (event.data && typeof event.data === 'object' && !Array.isArray(event.data)) {
                         const completion = event.data;
+                        const usage = completion.usage && typeof completion.usage === 'object' && !Array.isArray(completion.usage)
+                            ? completion.usage
+                            : undefined;
+                        if (usage) {
+                            const input = typeof usage.inputTokens === 'number' ? usage.inputTokens.toLocaleString() : '未知';
+                            const output = typeof usage.outputTokens === 'number' ? usage.outputTokens.toLocaleString() : '未知';
+                            const costs = Array.isArray(usage.providerCosts) ? usage.providerCosts.filter((item) => Boolean(item && typeof item === 'object' && typeof item.currency === 'string' && typeof item.amount === 'number')) : [];
+                            const estimate = usage.estimatedCost && typeof usage.estimatedCost === 'object' ? usage.estimatedCost : undefined;
+                            const costLabel = costs.length ? costs.map((item) => `${item.amount} ${item.currency}`).join(', ') : estimate && typeof estimate.amount === 'number' ? `估算 ${estimate.amount} ${String(estimate.currency)} (价格 ${String(estimate.pricingVersion)})` : '费用未知';
+                            addAssistantMessage({ id: `run-usage-${run.id}`, role: 'system', text: `用量：输入 ${input} · 输出 ${output} · ${costLabel}${usage.completeness === 'partial' ? ' · 数据不完整' : ''}`, createdAt: new Date().toISOString(), runId: run.id });
+                        }
+                        const taskOutcome = completion.taskOutcome && typeof completion.taskOutcome === 'object' && !Array.isArray(completion.taskOutcome)
+                            ? completion.taskOutcome
+                            : undefined;
+                        if (taskOutcome && typeof taskOutcome.status === 'string') {
+                            const labels = {
+                                accepted: '任务验收通过',
+                                incomplete: '任务未完成',
+                                unverifiable: '任务结果无法核验',
+                                failed: '任务执行失败',
+                                cancelled: '任务已取消',
+                            };
+                            addAssistantMessage({
+                                id: `task-outcome-${run.id}`,
+                                role: 'system',
+                                text: labels[taskOutcome.status] ?? `任务验收状态：${taskOutcome.status}`,
+                                createdAt: new Date().toISOString(),
+                                runId: run.id,
+                            });
+                        }
                         const completionError = completion.error;
                         if (completion.status === 'failed' && completionError && typeof completionError === 'object' && !Array.isArray(completionError)) {
                             const error = completionError;

package/dist/hooks/useSlashCommands.d.ts

@@ -1,5 +1,6 @@
 import type { SlashCommand } from '../types.js';
 export interface SlashCommandDependencies {
+    onMouse?: (args: string) => void | Promise<void>;
     onHelp?: () => void | Promise<void>;
     onStatus?: () => void | Promise<void>;
     onTools?: () => void | Promise<void>;

package/dist/hooks/useSlashCommands.js

@@ -1,6 +1,7 @@
 import { useMemo, useCallback } from 'react';
 export function useSlashCommands(deps) {
     const commands = useMemo(() => [
+        { name: '/mouse', description: '滚轮和触控板滚动 [on|off]', execute: async (args) => deps.onMouse?.(args) },
         { name: '/help', aliases: ['/h'], description: '显示帮助信息', execute: async () => deps.onHelp?.() },
         { name: '/status', description: '查看状态', execute: async () => deps.onStatus?.() },
         { name: '/tools', description: '列出可用工具', execute: async () => deps.onTools?.() },

package/dist/utils/markdown.js

@@ -57,7 +57,7 @@ function renderToken(token) {
         }
         case 'codespan': {
             const t = token;
-            return chalk.bgGray.white(` ${t.text} `);
+            return chalk.hex(theme.accent)(t.text);
         }
         case 'strong': {
             const t = token;

package/dist/utils/mouse.d.ts

@@ -0,0 +1,6 @@
+/** SGR mouse reporting. Ink removes the first ESC before delivering unknown keys. */
+export declare function mouseEvent(input: string): {
+    wheel: number;
+} | undefined;
+export declare const enableMouse = "\u001B[?1000h\u001B[?1006h";
+export declare const disableMouse = "\u001B[?1006l\u001B[?1000l";

package/dist/utils/mouse.js

@@ -0,0 +1,11 @@
+/** SGR mouse reporting. Ink removes the first ESC before delivering unknown keys. */
+export function mouseEvent(input) {
+    const match = /^(?:\x1b)?\[<(\d+);\d+;\d+([Mm])$/.exec(input);
+    if (!match)
+        return undefined;
+    const button = Number(match[1]);
+    const base = button & ~28; // Shift, Alt and Ctrl modifiers do not change direction.
+    return { wheel: match[2] === 'M' && base === 64 ? -3 : match[2] === 'M' && base === 65 ? 3 : 0 };
+}
+export const enableMouse = '\x1b[?1000h\x1b[?1006h';
+export const disableMouse = '\x1b[?1006l\x1b[?1000l';

package/dist/utils/transcript.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayMessage, Verbosity } from '../types.js';
+/** One shared rendering and wrapping path; scroll offsets are actual terminal rows. */
+export declare function transcriptLines(messages: DisplayMessage[], width: number, verbosity?: Verbosity): string[];
+export declare function scrollAction(input: string, key: {
+    ctrl?: boolean;
+    pageUp?: boolean;
+    pageDown?: boolean;
+    meta?: boolean;
+    upArrow?: boolean;
+    downArrow?: boolean;
+}): 'up' | 'down' | 'bottom' | undefined;

package/dist/utils/transcript.js

@@ -0,0 +1,37 @@
+import wrapAnsi from 'wrap-ansi';
+import chalk from 'chalk';
+import { stripTerminalControls } from './ansi.js';
+import { renderMarkdownToAnsi } from './markdown.js';
+/** One shared rendering and wrapping path; scroll offsets are actual terminal rows. */
+export function transcriptLines(messages, width, verbosity = 'normal') {
+    const blocks = messages.map((message) => {
+        const text = stripTerminalControls(message.text);
+        if (message.role === 'user')
+            return chalk.cyan(`你 › ${text}`);
+        if (message.role === 'system')
+            return chalk.dim(text);
+        const parts = [];
+        const tools = message.toolCalls ?? [];
+        if (verbosity !== 'quiet' && tools.length) {
+            const failed = tools.filter((tool) => tool.status === 'failed' || tool.status === 'cancelled');
+            parts.push(chalk.dim(`工具 · ${tools.filter((tool) => tool.status === 'succeeded').length}/${tools.length} 已完成${failed.length ? ` · ${failed.length} 未成功` : ''}`));
+            for (const tool of verbosity === 'verbose' ? tools : failed) {
+                const detail = `${tool.name} · ${tool.status}${verbosity === 'verbose' ? `\n${JSON.stringify(tool.arguments ?? {}, null, 2)}` : ''}${tool.result === undefined ? '' : `\n${typeof tool.result === 'string' ? tool.result : JSON.stringify(tool.result, null, 2)}`}`;
+                parts.push(chalk.dim(stripTerminalControls(detail)));
+            }
+        }
+        if (text)
+            parts.push(chalk.cyan.bold('Pulse'), renderMarkdownToAnsi(text));
+        return parts.join('\n');
+    }).filter(Boolean);
+    return wrapAnsi(blocks.join('\n\n'), Math.max(8, width), { hard: true, trim: false }).split('\n');
+}
+export function scrollAction(input, key) {
+    if (key.pageUp || (key.ctrl && input === 'p'))
+        return 'up';
+    if (key.pageDown || (key.ctrl && input === 'n'))
+        return 'down';
+    if (key.ctrl && input === 'g')
+        return 'bottom';
+    return undefined;
+}

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "@hunterzhu/pulse-cli",
-  "version": "0.1.10",
+  "version": "0.2.0",
+  "description": "A local-first AI task assistant for coding, research, and file workflows.",
+  "keywords": [
+    "ai",
+    "agent",
+    "assistant",
+    "cli",
+    "coding",
+    "research",
+    "task-runner"
+  ],
+  "homepage": "https://github.com/zhuhengtan/Pulse#readme",
   "repository": {
     "type": "git",
     "url": "https://github.com/zhuhengtan/Pulse"
@@ -24,15 +35,16 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@hunterzhu/pulse-server": "0.1.10",
+    "@hunterzhu/pulse-server": "0.2.0",
+    "chalk": "^5.4.1",
+    "highlight.js": "^11.10.0",
     "ink": "^7.1.1",
-    "react": "^19.0.0",
-    "ink-spinner": "^5.0.0",
     "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "marked": "^14.0.0",
-    "highlight.js": "^11.10.0",
-    "chalk": "^5.4.1"
+    "react": "^19.0.0",
+    "wrap-ansi": "10.0.2"
   },
   "devDependencies": {
     "@types/react": "^19.0.0"