pikiloom 0.4.37 → 0.4.39

package/dist/agent/kernel-bridge.js

@@ -0,0 +1,207 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { agentLog, agentWarn } from './utils.js';
+import { normalizeClaudeSessionEntrypoint } from './drivers/claude.js';
+import { humanizeCodexError } from './drivers/codex.js';
+// ── The cutover seam: route an agent turn through @pikiloom/kernel ──────────────
+//
+// DEFAULT: ON — claude/codex/gemini/hermes turns run on the kernel drivers (via runTurn).
+// Escape hatches to the legacy driver path:
+//   LOOM_KERNEL_PIPELINE=0             (env; force legacy at startup; survives dev.sh scrub)
+//   ~/.pikiloom/dev/kernel-legacy.on   (file; hot-toggle legacy without restart)
+//   LOOM_KERNEL_PIPELINE=1             (env; force kernel, overriding the file)
+// Tests always run legacy (the unit suite asserts legacy driver behavior). The bridge
+// re-applies app-level parity the pure kernel must not own (claude jsonl entrypoint, codex humanize).
+const KERNEL_AGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
+export function shouldUseKernelPipeline(agent) {
+    if (!KERNEL_AGENTS.has(agent))
+        return false;
+    if (process.env.VITEST || process.env.NODE_ENV === 'test')
+        return false; // tests assert legacy
+    if (process.env.LOOM_KERNEL_PIPELINE === '0')
+        return false; // explicit legacy
+    if (process.env.LOOM_KERNEL_PIPELINE === '1')
+        return true; // explicit kernel
+    try {
+        if (fs.existsSync(path.join(os.homedir(), '.pikiloom', 'dev', 'kernel-legacy.on')))
+            return false;
+    }
+    catch { /* ignore */ }
+    return true; // default: kernel
+}
+// Build the kernel driver instance + the per-agent AgentTurnInput from pikiloom StreamOpts.
+function buildKernelDriver(kernel, opts) {
+    const common = {
+        prompt: opts.prompt,
+        workdir: opts.workdir,
+        sessionId: opts.sessionId ?? null,
+        attachments: opts.attachments,
+        effort: opts.thinkingEffort,
+        env: opts.extraEnv,
+        mcpConfigPath: opts.mcpConfigPath ?? null,
+    };
+    switch (opts.agent) {
+        case 'codex': {
+            // codexExtraArgs is a flattened ['-c','k=v','-c','k=v',...]; extract the k=v values
+            // so the kernel keeps BYOK provider routing.
+            const ce = opts.codexExtraArgs || [];
+            const configOverrides = [];
+            for (let i = 0; i < ce.length; i++)
+                if (ce[i] === '-c' && ce[i + 1])
+                    configOverrides.push(ce[++i]);
+            return { driver: new kernel.CodexDriver(), input: { ...common, model: opts.codexModel ?? opts.model ?? null, systemPrompt: opts.codexDeveloperInstructions, configOverrides, fullAccess: opts.codexFullAccess } };
+        }
+        case 'gemini':
+            return { driver: new kernel.GeminiDriver(), input: { ...common, model: opts.geminiModel ?? opts.model ?? null, systemPrompt: opts.geminiSystemInstruction, extraArgs: opts.geminiExtraArgs } };
+        case 'hermes':
+            return { driver: new kernel.HermesDriver(), input: { ...common, model: opts.hermesModel ?? opts.model ?? null } };
+        case 'claude':
+        default:
+            return {
+                driver: new kernel.ClaudeDriver(),
+                input: { ...common, model: opts.claudeModel ?? opts.model ?? null, systemPrompt: opts.claudeAppendSystemPrompt, permissionMode: opts.claudePermissionMode ?? null, extraArgs: opts.claudeExtraArgs, steerable: !!opts.onSteerReady },
+            };
+    }
+}
+let _kernel = null;
+export async function loadKernel() {
+    if (_kernel)
+        return _kernel;
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(here, '../../packages/kernel/dist/index.js'), // src/agent (dev) & dist/agent (prod) -> <repo>/packages/kernel
+        path.resolve(process.cwd(), 'packages/kernel/dist/index.js'),
+    ];
+    // Prefer an installed package if present, else the in-repo built dist.
+    // (specifier kept in a variable so tsc treats it as a dynamic any, not a static resolve)
+    const pkgName = '@pikiloom/kernel';
+    try {
+        _kernel = await import(pkgName);
+        return _kernel;
+    }
+    catch { /* not installed */ }
+    for (const c of candidates) {
+        if (fs.existsSync(c)) {
+            _kernel = await import(pathToFileURL(c).href);
+            return _kernel;
+        }
+    }
+    throw new Error(`@pikiloom/kernel not found (build it: npm run build in packages/kernel). Looked in: ${candidates.join(', ')}`);
+}
+// A kernel 'artifact' (e.g. a generated image as a data URL) -> write to a temp file and
+// deliver through pikiloom's normal file-delivery seam (same path as im_send_file).
+async function deliverKernelArtifact(artifact, opts) {
+    try {
+        const send = opts.mcpSendFile;
+        if (typeof send !== 'function' || !artifact?.url)
+            return;
+        const m = String(artifact.url).match(/^data:([^;]+);base64,(.*)$/s);
+        if (!m)
+            return;
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kernel-art-'));
+        const file = path.join(dir, artifact.fileName || 'artifact.bin');
+        fs.writeFileSync(file, Buffer.from(m[2], 'base64'));
+        await send(file, { kind: artifact.kind || 'document', caption: artifact.caption });
+    }
+    catch { /* best-effort delivery */ }
+}
+export async function kernelStream(opts) {
+    const start = Date.now();
+    const kernel = await loadKernel();
+    const { driver, input } = buildKernelDriver(kernel, opts);
+    agentLog(`[kernel-bridge] routing ${opts.agent} turn via @pikiloom/kernel ${driver?.constructor?.name || 'Driver'}`);
+    let delivered = 0; // artifacts already sent out-of-band
+    let seenSid = null;
+    // SessionRunner (via runTurn) owns the event accumulation; the bridge only translates
+    // the kernel's UniversalSnapshot onto pikiloom's preview (onText) and delivers any new
+    // artifacts through the normal file seam. This is the "product bridge" pattern: map your
+    // request -> AgentTurnInput, map snapshot -> your UI, map result -> your result shape.
+    const onSnapshot = (s) => {
+        const arts = s.artifacts || [];
+        for (; delivered < arts.length; delivered++)
+            void deliverKernelArtifact(arts[delivered], opts);
+        if (s.sessionId && s.sessionId !== seenSid) {
+            seenSid = s.sessionId;
+            try {
+                opts.onSessionId?.(s.sessionId);
+            }
+            catch { /* ignore */ }
+        }
+        const m = {
+            inputTokens: s.usage?.inputTokens ?? null,
+            outputTokens: s.usage?.outputTokens ?? null,
+            cachedInputTokens: s.usage?.cachedInputTokens ?? null,
+            contextUsedTokens: s.usage?.contextUsedTokens ?? null,
+            contextPercent: s.usage?.contextPercent ?? null,
+            turnOutputTokens: s.usage?.turnOutputTokens ?? null,
+            toolCalls: s.toolCalls?.length ? s.toolCalls : undefined,
+            subAgents: s.subAgents?.length ? s.subAgents : undefined,
+            providerName: opts.byokProviderName ?? null,
+        };
+        try {
+            opts.onText(s.text || '', s.reasoning || '', s.activity || '', m, s.plan ?? null);
+        }
+        catch { /* isolate */ }
+    };
+    let result;
+    let snapshot = {};
+    try {
+        ({ result, snapshot } = await kernel.runTurn(driver, input, {
+            onSnapshot,
+            onSteer: (fn) => { try {
+                opts.onSteerReady?.(fn);
+            }
+            catch { /* ignore */ } },
+            signal: opts.abortSignal,
+        }));
+    }
+    catch (err) {
+        agentWarn(`[kernel-bridge] kernel run failed: ${err?.message || err}`);
+        result = { ok: false, text: '', error: err?.message || String(err), stopReason: 'error', sessionId: opts.sessionId ?? null };
+    }
+    const finalSessionId = result.sessionId || snapshot.sessionId || opts.sessionId || null;
+    if (finalSessionId && finalSessionId !== seenSid) {
+        try {
+            opts.onSessionId?.(finalSessionId);
+        }
+        catch { /* ignore */ }
+    }
+    // App-level parity the pure kernel must not own (mirrors legacy *.doStream):
+    //  - claude: rewrite the native jsonl entrypoint sdk-cli->cli (VSCode session visibility).
+    //  - codex: translate raw provider error JSON (ChatGPT-account / third-party) to prose.
+    if (opts.agent === 'claude') {
+        try {
+            normalizeClaudeSessionEntrypoint(opts.workdir, finalSessionId);
+        }
+        catch { /* best-effort */ }
+    }
+    const finalError = (opts.agent === 'codex' && result.error)
+        ? (humanizeCodexError(result.error) ?? result.error)
+        : (result.error ?? null);
+    const u = result.usage || snapshot.usage || {};
+    return {
+        ok: !!result.ok,
+        message: (result.text || snapshot.text || '').trim() || (finalError ?? '(no output)'),
+        thinking: (result.reasoning || snapshot.reasoning || '').trim() || null,
+        plan: snapshot.plan ?? null,
+        sessionId: finalSessionId,
+        workspacePath: null,
+        model: input.model ?? null,
+        thinkingEffort: opts.thinkingEffort,
+        elapsedS: (Date.now() - start) / 1000,
+        inputTokens: u.inputTokens ?? null,
+        outputTokens: u.outputTokens ?? null,
+        cachedInputTokens: u.cachedInputTokens ?? null,
+        cacheCreationInputTokens: null,
+        contextWindow: null,
+        contextUsedTokens: u.contextUsedTokens ?? null,
+        contextPercent: null,
+        codexCumulative: null,
+        error: finalError,
+        stopReason: result.stopReason ?? null,
+        incomplete: !result.ok,
+        activity: snapshot.activity || null,
+    };
+}

package/dist/agent/mcp/capabilities.js

@@ -0,0 +1,39 @@
+// Session tool capabilities: each co-locates a session MCP tool group (defined under
+// ./tools/) with the prompt fragment that teaches the agent to use it. This is the local,
+// decoupled analog of a @pikiloom/kernel Plugin (a capability = its tools + its usage
+// prompt, as one unit). pikiloom composes its own system prompt app-side and feeds the
+// kernel a finished string, so this module intentionally does NOT import the kernel — that
+// is what keeps pikiloom fully decoupled from the kernel's Hub/plugin runtime.
+const ARTIFACT_RETURN = [
+    '[Artifact Return]',
+    'To hand a file to the user — a screenshot, report, archive, generated asset, anything they asked you to "send" — call the `im_send_file` tool with the file path and a short caption. It is delivered through whatever terminal the user is on (an IM chat or the web dashboard) and stays retrievable even when they are connected remotely. Do NOT just print a local filesystem path: a remote user cannot open paths on this machine.',
+].join('\n');
+const ASK_USER = [
+    '[Asking the user]',
+    'The built-in `AskUserQuestion` tool is disabled here and will fail. If you would otherwise call it, call `mcp__pikiloom__im_ask_user` instead — same intent (a question plus optional choices), it blocks until the user replies via the IM/dashboard channel. Default behaviour is unchanged: infer obvious decisions yourself and only ask when you genuinely cannot proceed.',
+].join('\n');
+export const SESSION_TOOL_CAPABILITIES = [
+    {
+        id: 'artifact-delivery',
+        tools: ['im_send_file', 'im_list_files'],
+        promptFragment: () => ARTIFACT_RETURN,
+    },
+    {
+        id: 'ask-user',
+        tools: ['im_ask_user'],
+        // Only when the HITL path is wired and the agent is claude (codex/gemini handle asks natively).
+        promptFragment: ({ agent, onInteraction }) => (onInteraction && agent === 'claude') ? ASK_USER : null,
+    },
+];
+// Compose the session tool prompt = each capability's applicable fragment, in registration
+// order, joined by a blank line. Byte-identical to the prior inline assembly in bot.ts.
+export function composeSessionToolPrompt(ctx) {
+    const parts = [];
+    for (const cap of SESSION_TOOL_CAPABILITIES) {
+        const fragment = cap.promptFragment(ctx);
+        const trimmed = String(fragment || '').trim();
+        if (trimmed)
+            parts.push(trimmed);
+    }
+    return parts.join('\n\n');
+}

package/dist/agent/stream.js

@@ -12,6 +12,7 @@ import { Q, agentLog, agentWarn, agentError, joinErrorMessages, normalizeErrorMe
 import { saveSessionRecord, setSessionRunState, applySessionRunResult, ensureSessionWorkspace, importFilesIntoWorkspace, syncManagedSessionIdentity, summarizePromptTitle, recordFork, resolveCanonicalSessionId, } from './session.js';
 import { clearAwaitResume } from './await-resume.js';
 import { collapseSkillPrompt } from './skills.js';
+import { shouldUseKernelPipeline, kernelStream } from './kernel-bridge.js';
 function trimSessionText(value, max = 24_000) {
     const text = typeof value === 'string' ? value.trim() : '';
     if (!text)
@@ -558,7 +559,24 @@ export async function doStream(opts) {
             throw new Error(`Agent ${prepared.agent} does not support fork`);
         }
         await awaitAgentUpdateIdle(prepared.agent, AGENT_UPDATE_TIMEOUTS.spawnWait);
-        const result = await driver.doStream(prepared);
+        // Cutover seam: when enabled (default ON for claude/codex/gemini/hermes), route the
+        // agent turn through @pikiloom/kernel. kernelStream throws ONLY if the kernel package
+        // can't be loaded (missing dist) — every in-turn error is returned as a result. So a
+        // throw here means "kernel unavailable": fall back to the legacy driver rather than
+        // failing the turn. See agent/kernel-bridge.ts.
+        let result;
+        if (shouldUseKernelPipeline(prepared.agent)) {
+            try {
+                result = await kernelStream(prepared);
+            }
+            catch (kernelErr) {
+                agentWarn(`[kernel-bridge] kernel unavailable, falling back to legacy driver: ${kernelErr?.message || kernelErr}`);
+                result = await driver.doStream(prepared);
+            }
+        }
+        else {
+            result = await driver.doStream(prepared);
+        }
         const finalized = finalizeStreamResult(result, opts.workdir, opts.prompt, session, opts.claudeWorkflowEnabled, opts.profileId);
         finalized.byokProviderName = prepared.byokProviderName ?? null;
         finalized.byokProfileName = prepared.byokProfileName ?? null;

package/dist/bot/bot.js

@@ -8,6 +8,7 @@ import { getActiveProfileId, getActiveProfile, setActiveProfile } from '../model
 import { querySessions, querySessionTail, updateSession, } from './session-hub.js';
 import { getDriver, hasDriver, allDriverIds, getDriverCapabilities } from '../agent/driver.js';
 import { resolveGuiIntegrationConfig } from '../agent/mcp/bridge.js';
+import { composeSessionToolPrompt } from '../agent/mcp/capabilities.js';
 import { terminateProcessTree } from '../core/process-control.js';
 import { expandTilde } from '../core/platform.js';
 import { VERSION } from '../core/version.js';
@@ -48,18 +49,6 @@ function appendExtraPrompt(base, extra) {
         return lhs;
     return `${lhs}\n\n${rhs}`;
 }
-function buildMcpDeliveryPrompt() {
-    return [
-        '[Artifact Return]',
-        'To hand a file to the user — a screenshot, report, archive, generated asset, anything they asked you to "send" — call the `im_send_file` tool with the file path and a short caption. It is delivered through whatever terminal the user is on (an IM chat or the web dashboard) and stays retrievable even when they are connected remotely. Do NOT just print a local filesystem path: a remote user cannot open paths on this machine.',
-    ].join('\n');
-}
-function buildClaudeAskUserPrompt() {
-    return [
-        '[Asking the user]',
-        'The built-in `AskUserQuestion` tool is disabled here and will fail. If you would otherwise call it, call `mcp__pikiloom__im_ask_user` instead — same intent (a question plus optional choices), it blocks until the user replies via the IM/dashboard channel. Default behaviour is unchanged: infer obvious decisions yourself and only ask when you genuinely cannot proceed.',
-    ].join('\n');
-}
 function buildBrowserAutomationPrompt(browserEnabled) {
     if (!browserEnabled) {
         return [
@@ -2022,7 +2011,9 @@ export class Bot {
         const workflowEnabled = cs.agent === 'claude' && (extras?.workflowEnabled ?? this.claudeWorkflowEnabled);
         const deliverySessionKey = ('key' in cs && typeof cs.key === 'string') ? cs.key : null;
         const wrappedSendFile = this.buildArtifactSendFile(cs.agent, deliverySessionKey, cs, mcpSendFile);
-        const mcpSystemPrompt = appendExtraPrompt(appendExtraPrompt(appendExtraPrompt(buildMcpDeliveryPrompt(), onInteraction && cs.agent === 'claude' ? buildClaudeAskUserPrompt() : ''), buildBrowserAutomationPrompt(browserEnabled)), workflowEnabled ? buildWorkflowOptInPrompt() : '');
+        // Session tool capabilities (im_send_file / im_ask_user) bundle their usage prompt with
+        // the tool itself — see agent/mcp/capabilities.ts. Browser/workflow remain session policy.
+        const mcpSystemPrompt = appendExtraPrompt(appendExtraPrompt(composeSessionToolPrompt({ agent: cs.agent, onInteraction: !!onInteraction }), buildBrowserAutomationPrompt(browserEnabled)), workflowEnabled ? buildWorkflowOptInPrompt() : '');
         const effectiveSystemPrompt = isFirstTurnOfSession
             ? appendExtraPrompt(systemPrompt, mcpSystemPrompt)
             : (mcpSystemPrompt || undefined);

package/dist/cli/kernel-app.js

@@ -0,0 +1,115 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadKernel } from '../agent/kernel-bridge.js';
+import { loadUserConfig, applyUserConfig } from '../core/config/user-config.js';
+import { resolveAgentInjection } from '../model/injector.js';
+// ── The "new version": pikiloom's backend booted ON @pikiloom/kernel ────────────
+//
+// Gated by LOOM_KERNEL_APP=1 (non-PIKILOOM_ prefix so it survives dev.sh's env scrub).
+//   LOOM_KERNEL_APP=1 npm run dev   -> this kernel runtime on the dashboard port
+//   npm run dev                      -> the legacy app (old version), untouched
+//
+// One createLoom() drives every agent through the kernel's Driver registry and exposes it
+// over a WebSurface carrying both lanes on one ws host: Lane S (web/structured snapshot) and
+// Lane R (raw PTY / terminal). The whole C1-C5 SDK surface (history, catalog, HITL, per-session
+// queue, wire) is live here.
+const DEMO_MODELS = {
+    claude: [{ id: 'claude-opus-4-8', label: 'Opus 4.8', providerName: 'anthropic', contextWindow: 200000 }],
+    codex: [{ id: 'gpt-5.5-codex', label: 'GPT-5.5 Codex', providerName: 'openai', contextWindow: 400000 }],
+    gemini: [{ id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', providerName: 'google', contextWindow: 1000000 }],
+    echo: [{ id: 'echo-1', label: 'Echo (hermetic)', providerName: 'local', contextWindow: 8192 }],
+};
+export async function runKernelApp(argv) {
+    const i = argv.indexOf('--dashboard-port');
+    const port = (i >= 0 && parseInt(argv[i + 1], 10)) || 3940;
+    const k = await loadKernel();
+    const { createLoom, ClaudeDriver, CodexDriver, GeminiDriver, HermesDriver, EchoDriver, WebSurface } = k;
+    // Load providers/profiles so the active BYOK/豆包 bindings are visible to the resolver.
+    try {
+        applyUserConfig(loadUserConfig(), undefined, { overwrite: true, clearMissing: true });
+    }
+    catch (e) {
+        console.log(`[kernel-app] config load: ${e?.message || e}`);
+    }
+    // REAL ModelResolver: delegate to pikiloom's resolveAgentInjection (BYOK / 豆包 / native).
+    // null => native CLI login; else map the InjectedSpawnConfig onto the kernel's ModelInjection.
+    const modelResolver = {
+        async resolve(agent, opts) {
+            let inj = null;
+            try {
+                inj = await resolveAgentInjection(agent, opts.profileId ?? undefined);
+            }
+            catch (e) {
+                console.log(`[kernel-app] inject ${agent} failed: ${e?.message || e}`);
+                return null;
+            }
+            if (!inj)
+                return null; // no active profile → native login
+            const env = { ...(inj.env || {}) };
+            if (inj.homeOverride)
+                env.HOME = inj.homeOverride;
+            if (inj.configFiles && Object.keys(inj.configFiles).length)
+                console.log(`[kernel-app] note: ${agent} injection has configFiles (not yet threaded through kernel)`);
+            return {
+                model: inj.modelOverride ?? opts.model ?? null,
+                env,
+                extraArgs: inj.argvAppend?.length ? inj.argvAppend : undefined,
+                configOverrides: inj.codexConfigOverrides?.length ? inj.codexConfigOverrides : undefined,
+                providerName: inj.providerName ?? null,
+                contextWindow: inj.contextWindow ?? null,
+            };
+        },
+    };
+    // Discovery (C2). A full cutover wires pikiloom's runtime-config / catalog / mcp SSOT
+    // through this port; here a representative catalog proves discovery end to end.
+    const catalog = {
+        async listModels({ agent }) { return DEMO_MODELS[agent] || []; },
+        async listEffort() { return [{ id: 'low' }, { id: 'medium' }, { id: 'high' }]; },
+        async listTools() { return []; },
+        async listSkills() { return []; },
+    };
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    let html = '<!doctype html><meta charset=utf-8><title>pikiloom · kernel</title>'
+        + '<body style="font:14px system-ui;padding:2rem;max-width:42rem">'
+        + '<h1>pikiloom — kernel runtime (new version)</h1>'
+        + '<p>The WebSurface ws host is live on this port. Connect any pikichannel/ws client and speak the UniversalSnapshot wire protocol (hello → subscribe → prompt; getHistory / getCatalog).</p>';
+    for (const c of [
+        path.resolve(here, '../../packages/kernel/examples/console.html'),
+        path.resolve(process.cwd(), 'packages/kernel/examples/console.html'),
+    ]) {
+        try {
+            html = fs.readFileSync(c, 'utf8');
+            break;
+        }
+        catch { /* fallback inline */ }
+    }
+    const server = http.createServer((req, res) => {
+        if (req.method === 'GET' && (req.url === '/' || req.url?.startsWith('/?'))) {
+            res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-cache' });
+            res.end(html);
+            return;
+        }
+        res.writeHead(404);
+        res.end('not found');
+    });
+    // WebSurface serves BOTH lanes: Lane S (Web/structured snapshot) and Lane R (Surface/
+    // raw PTY, via the TuiHost the kernel hands it at start). One ws host, two lanes.
+    const web = new WebSurface({ server, name: 'pikiloom-kernel' });
+    const surfaces = [web];
+    const loom = createLoom({
+        appNamespace: 'pikiloom-kernel',
+        drivers: [new EchoDriver(), new ClaudeDriver(), new CodexDriver(), new GeminiDriver(), new HermesDriver()],
+        defaultAgent: 'claude',
+        surfaces,
+        catalog,
+        modelResolver,
+        log: (m) => console.log(`[kernel-app] ${m}`),
+    });
+    await loom.start();
+    await new Promise((resolve) => server.listen(port, () => resolve()));
+    const st = loom.status();
+    console.log(`[kernel-app] NEW VERSION up — http+ws http://localhost:${port}  agents=${st.agents.join(',')}  surfaces=${st.surfaces.join(',')}`);
+    // The http+ws server keeps the process alive.
+}

package/dist/cli/main.js

@@ -590,6 +590,13 @@ async function launchChannels(channels, dashboard) {
 export async function main() {
     if (await handleMcpServeMode())
         return;
+    // Cutover gate: LOOM_KERNEL_APP=1 boots the backend on @pikiloom/kernel (new version)
+    // instead of the legacy app. Non-PIKILOOM_ prefix so it survives dev.sh's env scrub.
+    if (process.env.LOOM_KERNEL_APP === '1') {
+        const { runKernelApp } = await import('./kernel-app.js');
+        await runKernelApp(process.argv.slice(2));
+        return;
+    }
     const args = parseArgs(process.argv.slice(2));
     let userConfig = loadUserConfig();
     if (args.version) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.37",
+  "version": "0.4.39",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "dist/",
     "dashboard/dist/",
+    "packages/kernel/dist/",
     "LICENSE",
     "README.md"
   ],
@@ -33,7 +34,8 @@
     "build:dashboard": "vite build --config dashboard/vite.config.ts",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "copy:pikichannel-web": "node -e \"require('fs').cpSync('src/pikichannel/web','dist/pikichannel/web',{recursive:true})\"",
-    "build": "npm run clean && npm run build:dashboard && tsc && npm run copy:pikichannel-web",
+    "build:kernel": "tsc -p packages/kernel/tsconfig.json",
+    "build": "npm run clean && npm run build:dashboard && tsc && npm run build:kernel && npm run copy:pikichannel-web",
     "postbuild": "node -e \"require('fs').chmodSync('dist/cli/main.js',0o755)\"",
     "prepack": "npm run build",
     "test": "vitest run",