pikiloom 0.4.39 → 0.4.41

package/dashboard/dist/assets/{shared-p3kZpiD4.js → shared-BKwEgcmy.js}

@@ -1 +1 @@
-import{j as s}from"./react-vendor-C7Sl8SE7.js";import{N as t,m as i,S as a}from"./index-yZ-iG1qk.js";function o({primary:e,secondary:l,tertiary:n}){return s.jsxs("div",{className:"flex flex-col gap-2 pt-1 sm:flex-row sm:flex-wrap sm:items-center sm:justify-between",children:[s.jsxs("div",{className:"flex flex-wrap items-center gap-2",children:[e&&s.jsxs(i,{tone:"primary",onClick:e.onClick,disabled:e.disabled,children:[e.loading&&s.jsx(a,{}),e.label]}),l&&s.jsx(i,{tone:"secondary",onClick:l.onClick,disabled:l.disabled,children:l.label})]}),n&&s.jsx("div",{className:"text-xs leading-relaxed text-fg-4",children:n})]})}function c({children:e,className:l}){return s.jsx(t,{padding:"md",elevation:"flat",className:l,children:e})}export{o as A,c as S};
+import{j as s}from"./react-vendor-C7Sl8SE7.js";import{N as t,m as i,S as a}from"./index-D18pCeqv.js";function o({primary:e,secondary:l,tertiary:n}){return s.jsxs("div",{className:"flex flex-col gap-2 pt-1 sm:flex-row sm:flex-wrap sm:items-center sm:justify-between",children:[s.jsxs("div",{className:"flex flex-wrap items-center gap-2",children:[e&&s.jsxs(i,{tone:"primary",onClick:e.onClick,disabled:e.disabled,children:[e.loading&&s.jsx(a,{}),e.label]}),l&&s.jsx(i,{tone:"secondary",onClick:l.onClick,disabled:l.disabled,children:l.label})]}),n&&s.jsx("div",{className:"text-xs leading-relaxed text-fg-4",children:n})]})}function c({children:e,className:l}){return s.jsx(t,{padding:"md",elevation:"flat",className:l,children:e})}export{o as A,c as S};

package/dashboard/dist/index.html

@@ -6,7 +6,7 @@
   <link rel="icon" type="image/png" href="/logo.png">
   <title>Pikiloom</title>
   <link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600;700&family=Geist+Mono:wght@400;500&display=swap" rel="stylesheet">
-  <script type="module" crossorigin src="/assets/index-yZ-iG1qk.js"></script>
+  <script type="module" crossorigin src="/assets/index-D18pCeqv.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/react-vendor-C7Sl8SE7.js">
   <link rel="modulepreload" crossorigin href="/assets/router-DHISdpPk.js">
   <link rel="stylesheet" crossorigin href="/assets/index-Bthwt6K_.css">

package/dist/agent/drivers/codex.js

@@ -34,9 +34,11 @@ export class CodexAppServer {
         return new Promise((resolve) => {
             const timer = setTimeout(() => { this.kill(); resolve(false); }, CODEX_APPSERVER_SPAWN_TIMEOUT_MS);
             const args = ['app-server'];
-            const overrides = this.configOverrides.some(entry => /^features\.goals\s*=/.test(entry))
-                ? this.configOverrides
-                : [...this.configOverrides, 'features.goals=true'];
+            // Do NOT force model_reasoning_summary — reasoning summaries stay OFF by default (respecting
+            // ~/.codex/config.toml = original behavior). A caller wanting thinking passes it via configOverrides.
+            const overrides = [...this.configOverrides];
+            if (!overrides.some(entry => /^features\.goals\s*=/.test(entry)))
+                overrides.push('features.goals=true');
             for (const c of overrides)
                 args.push('-c', c);
             agentLog(`[codex-rpc] spawning: codex ${args.join(' ')}`);

package/dist/agent/index.js

@@ -7,7 +7,7 @@ export { attachAgentImage, attachInlineImage, materializeImage, rewriteAttachmen
 export { deliverArtifact, readDeliveredArtifacts, deliveredArtifactBlocks, tailDeliveredBlocks, latestDeliveredTaskId, mimeForArtifact, } from './artifacts.js';
 export { Q, agentLog, agentWarn, agentError, dedupeStrings, numberOrNull, normalizeStreamPreviewPlan, parseTodoWriteAsPlan, normalizeActivityLine, pushRecentActivity, detectClaudeApiError, isRetryableClaudeApiError, detectClaudeModelError, claudeModelErrorMessage, firstNonEmptyLine, shortValue, normalizeErrorMessage, joinErrorMessages, appendSystemPrompt, mimeForExt, computeContext, buildStreamPreviewMeta, summarizeClaudeToolUse, summarizeClaudeToolResult, previewToolCallInput, previewToolCallResult, roundPercent, toIsoFromEpochSeconds, normalizeUsageStatus, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, modelFamily, normalizeClaudeModelId, emptyUsage, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, stripClaudeAtMentionImages, isPendingSessionId, emitSessionIdUpdate, sessionListDisplayTitle, } from './utils.js';
 export { updateSessionMeta, promoteSessionId, recordFork, resolveCanonicalSessionId, getSessionPromotions, listPikiloomSessions, findPikiloomSession, getSessionStoredConfig, ensureManagedSession, findManagedThreadSession, stageSessionFiles, mergeManagedAndNativeSessions, managedRecordToSessionInfo, getSessions, getSessionTail, getSessionMessages, applyTurnWindow, applyTurnFilter, classifySession, deriveUserStatus, exportSession, importSession, deleteAgentSession, isProcessAlive, isRunningSessionStale, reconcileOrphanedRunningSessions, } from './session.js';
-export { detectAgentBin, listAgents, resolveDefaultAgent, run, doStream, recoverProfileIdForModel, listModels, resolveAgentModels, getUsage, getAgentBoundModelId, setAgentBoundModelId, } from './stream.js';
+export { detectAgentBin, listAgents, resolveDefaultAgent, run, doStream, recoverProfileIdForModel, listModels, resolveAgentModels, dropNativeShadowedByProfiles, getUsage, getAgentBoundModelId, setAgentBoundModelId, } from './stream.js';
 export { registerDriver, getDriver, getDriverCapabilities, allDrivers, allDriverIds, hasDriver, shutdownAllDrivers, } from './driver.js';
 export { getProjectSkillPaths, initializeProjectSkills, listSkills, getGlobalSkillsRoot, collapseSkillPrompt, } from './skills.js';
 export { readGoal, writeGoal, clearGoal, setGoal, pauseGoal, resumeGoal, completeGoal, accountTurn, bumpContinuationCount, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, sessionGoalPath, DEFAULT_MAX_CONTINUATIONS, } from './goal.js';

package/dist/agent/stream.js

@@ -658,6 +658,17 @@ export function listModels(agent, opts = {}) {
 function isLocalProviderBaseURL(baseURL) {
     return /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::|\/|$)/i.test(baseURL);
 }
+// A model surfaced as a BYOK profile must NOT also appear under the native group. Drivers seed
+// their native list with the active model (via opts.currentModel) so it stays visible — but when
+// a BYOK profile is active that "current model" is the profile's third-party model (e.g. a 豆包 /
+// deepseek id), which then wrongly shows up as an "official / 官方 / Native" model. The profile row
+// already represents it, so drop any native entry shadowed by a profile id.
+export function dropNativeShadowedByProfiles(native, profileRows) {
+    if (!profileRows.length)
+        return native;
+    const shadowed = new Set(profileRows.map(m => m.id.trim().toLowerCase()).filter(Boolean));
+    return native.filter(m => !shadowed.has(m.id.trim().toLowerCase()));
+}
 export async function resolveAgentModels(agent, opts = {}) {
     const driver = getDriver(agent);
     let nativeResult;
@@ -667,7 +678,7 @@ export async function resolveAgentModels(agent, opts = {}) {
     catch {
         nativeResult = { agent, models: [], sources: [], note: null };
     }
-    const native = nativeResult.models.map(m => ({
+    const nativeRaw = nativeResult.models.map(m => ({
         id: m.id,
         alias: m.alias,
         group: 'native',
@@ -693,6 +704,7 @@ export async function resolveAgentModels(agent, opts = {}) {
             (isLocal ? local : cloud).push(entry);
         }
     }
+    const native = dropNativeShadowedByProfiles(nativeRaw, [...cloud, ...local]);
     const sources = [...nativeResult.sources];
     if (cloud.length)
         sources.push(`${cloud.length} cloud profile${cloud.length === 1 ? '' : 's'}`);

package/dist/bot/render-shared.js

@@ -3,6 +3,7 @@ import { fmtUptime, formatThinkingForDisplay, thinkLabel } from './bot.js';
 import { formatActivityCommandSummary, parseActivitySummary, renderPlanForPreview, summarizeActivityForPreview } from './streaming.js';
 import { supportsChannelCapability } from '../channels/base.js';
 import { agentLog, agentWarn } from '../agent/index.js';
+import { effortLabel } from '../core/config/runtime-config.js';
 export function parseGfmTable(tableLines) {
     if (tableLines.length < 3)
         return null;
@@ -53,7 +54,7 @@ export function formatFooterParts(agent, elapsedMs, meta, contextPercent, decora
         identityParts.push(compactModelLabel(modelLabel));
     const runtimeParts = [];
     if (decorations?.effort)
-        runtimeParts.push(decorations.effort);
+        runtimeParts.push(effortLabel(decorations.effort));
     const ctx = contextPercent ?? meta?.contextPercent ?? null;
     if (ctx != null)
         runtimeParts.push(`${ctx}%`);

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

@@ -164,34 +164,26 @@ export function decomposeEffortSelection(raw) {
         return { effort: 'max', workflow: true };
     return { effort: value, workflow: false };
 }
+// The one canonical, human-facing name for an effort token. The picker (effortOptionsFor →
+// dashboard composer + IM /models), the dashboard turn header, and the IM agent-status row all
+// render this, so a level reads identically on every surface — no upper layer relabels it. We
+// surface the raw token (low/medium/high/xhigh/max/ultra/minimal), not a prose label like
+// "Very High", to match the id used in config, CLI flags and logs. Change presentation here only.
+export function effortLabel(id) {
+    return (id ?? '').trim().toLowerCase();
+}
 // Single source of truth for reasoning-effort levels, ordered low→high. BOTH the dashboard
 // (which receives them via the agent/model API payload) and the IM bot consume this — do not
 // reintroduce a second copy. Resolve options through effortOptionsFor(), never index directly,
-// so per-model/provider rules stay in one place.
+// so per-model/provider rules stay in one place. Labels come from effortLabel() so the picker
+// and the live status row can never diverge.
+const effortLevels = (...ids) => ids.map(id => ({ id, label: effortLabel(id) }));
 const AGENT_EFFORT_LEVELS = {
-    claude: [
-        { id: 'low', label: 'Low' },
-        { id: 'medium', label: 'Medium' },
-        { id: 'high', label: 'High' },
-        { id: 'xhigh', label: 'Very High' },
-        { id: 'max', label: 'Max' },
-        { id: ULTRA_EFFORT, label: 'Ultra' },
-    ],
-    codex: [
-        { id: 'low', label: 'Low' },
-        { id: 'medium', label: 'Medium' },
-        { id: 'high', label: 'High' },
-        { id: 'xhigh', label: 'Very High' },
-    ],
+    claude: effortLevels('low', 'medium', 'high', 'xhigh', 'max', ULTRA_EFFORT),
+    codex: effortLevels('low', 'medium', 'high', 'xhigh'),
     // gemini intentionally has no UI-exposed effort levels: pikiloom sends it no reasoning-effort
     // (see the gemini→null guards in InputComposer). Add a gemini entry here to surface low/high.
-    hermes: [
-        { id: 'minimal', label: 'Minimal' },
-        { id: 'low', label: 'Low' },
-        { id: 'medium', label: 'Medium' },
-        { id: 'high', label: 'High' },
-        { id: 'xhigh', label: 'Very High' },
-    ],
+    hermes: effortLevels('minimal', 'low', 'medium', 'high', 'xhigh'),
 };
 // Valid effort levels for a given (agent, model, providerKind). Returns [] when reasoning
 // effort does not apply (the UI then hides the selector entirely). model/providerKind are the

package/dist/dashboard/routes/agents.js

@@ -137,6 +137,11 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
         }
         const runtimeSelectedModel = runtime.getRuntimeModel(agentId, config);
         const runtimeSelectedEffort = runtime.getRuntimeEffort(agentId, config);
+        const activeProfile = getActiveProfile(agentId);
+        // runtimeSelectedModel is the model that will RUN (profile-aware): when a BYOK profile is
+        // bound it is the profile's third-party model. The NATIVE model list must not be seeded with
+        // it, else it shows under the "官方 / Native" group (it is surfaced separately via byokModels).
+        const nativeRuntimeModel = activeProfile ? '' : runtimeSelectedModel;
         let models = [];
         let usage = emptyUsage(agentId, 'Agent not installed.');
         let nativeConfig = null;
@@ -149,10 +154,10 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
                     }
                     catch { }
                 }
-                const modelFallback = runtimeSelectedModel ? [{ id: runtimeSelectedModel, alias: null }] : [];
+                const modelFallback = nativeRuntimeModel ? [{ id: nativeRuntimeModel, alias: null }] : [];
                 const cachedUsage = driver.getUsage({ agent: agentId, model: runtimeSelectedModel });
                 const [resolvedModels, resolvedUsage] = await Promise.all([
-                    withTimeoutFallback(driver.listModels({ workdir, currentModel: runtimeSelectedModel }).then(result => dedupeModels([
+                    withTimeoutFallback(driver.listModels({ workdir, currentModel: nativeRuntimeModel || undefined }).then(result => dedupeModels([
                         ...modelFallback,
                         ...result.models,
                     ])), AGENT_STATUS_MODELS_TIMEOUT_MS, modelFallback),
@@ -169,14 +174,13 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
             }
         }
         const updateState = getAgentUpdateState(agentId);
-        const activeProfile = getActiveProfile(agentId);
         const byokProvider = activeProfile ? getProvider(activeProfile.providerId) : null;
         const byokProviderName = byokProvider?.name || null;
         const byokProfileName = activeProfile
             && activeProfile.name.trim().toLowerCase() !== activeProfile.modelId.trim().toLowerCase()
             ? activeProfile.name
             : null;
-        const nativeSelectedModel = runtimeSelectedModel || nativeConfig?.model || null;
+        const nativeSelectedModel = nativeRuntimeModel || nativeConfig?.model || null;
         const nativeSelectedEffort = runtimeSelectedEffort || nativeConfig?.effort || null;
         const selectedModel = activeProfile?.modelId || nativeSelectedModel;
         const selectedEffort = activeProfile?.effort || nativeSelectedEffort;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.39",
+  "version": "0.4.41",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/README.md

@@ -275,6 +275,40 @@ plugins are the composable per-capability layer on top.)
 
 ---
 
+## Workspace: unified directory + session / skill / mcp management
+
+One explicitly-configurable **top-level directory** (`createLoom({ stateDirName })`, default
+`'pikiloom'` → `.pikiloom`) gives a consuming app the same "everything under one folder" model
+pikiloom uses, resolved in two scopes — global (`~/.pikiloom`) and per-workspace
+(`<workdir>/.pikiloom`). It's exposed off the `Loom`:
+
+```ts
+const loom = createLoom({ drivers: [new ClaudeDriver(), new CodexDriver()], stateDirName: 'pikiloom' });
+
+// Unified, searchable session list — the kernel's MANAGED sessions (scoped per workspace by the
+// cwd they ran in) MERGED with each agent's OWN native sessions (claude/codex read their on-disk
+// transcripts). Global view, per-workspace view, and search — all kernel-owned:
+await loom.sessions.list({ scope: 'workspace', workdir });   // this folder (managed + native)
+await loom.sessions.list({ scope: 'global' });               // every workspace's managed sessions
+await loom.sessions.search({ query: 'deploy', workdir });
+
+// Skills registry: one canonical dir, symlinked into every agent's skills dir.
+loom.skills.ensureLinks('workspace', workdir);   // <wd>/.claude/skills + .agents/skills → <wd>/.pikiloom/skills
+loom.skills.list({ workdir });                   // installed skills (workspace + global)
+await loom.skills.search('pdf');                 // installable skills (npm)
+
+// MCP catalog + discovery (enabling a server stays on the Plugin.tools()/ToolProvider seam):
+loom.mcp.recommended();                           // curated catalog
+await loom.mcp.search('postgres');                // MCP registry → npm
+
+loom.paths.skillsDir('global');                   // ~/.pikiloom/skills, etc.
+```
+
+A driver opts into native discovery by implementing
+`listNativeSessions?({ workdir, limit }): NativeSessionInfo[]` (Claude/Codex/Gemini do; the pure
+readers are also exported as `discover{Claude,Codex,Gemini}NativeSessions`). All of this is
+node-builtins-only and additive — every existing port/default is unchanged.
+
 ## Exports
 
 Main entry `@pikiloom/kernel` re-exports everything. Subpaths: `@pikiloom/kernel/drivers`,
@@ -284,6 +318,7 @@ Main entry `@pikiloom/kernel` re-exports everything. Subpaths: `@pikiloom/kernel
 - Drivers: `EchoDriver`, `ClaudeDriver`, `CodexDriver`, `GeminiDriver`, `HermesDriver`
 - Surfaces: `WebSurface`, `CliSurface`
 - Ports/defaults: `FsSessionStore`, `NullModelResolver`, `NoopToolProvider`, `PassthroughSystemPromptBuilder`, `AutoCancelInteractionHandler`, `DeferToTerminalInteractionHandler`, `NoopCatalog`, `defaultBaseDir`
+- Workspace: `resolveLoomPaths`, `SessionsManager`, `SkillsManager`, `McpRegistry`, `ensureDirSymlink`, `discover{Claude,Codex,Gemini}NativeSessions` + types `LoomPaths`, `LoomScope`, `ManagedSessionInfo`, `NativeSessionInfo`, `SkillInfo`, `McpCatalogEntry`
 - Protocol: `UniversalSnapshot`, `diffSnapshot`, `applySnapshotPatch`, `emptySnapshot`, `PROTOCOL_VERSION`, all wire/`Client*`/`Server*` message types
 - Types: `AgentDriver`, `AgentTurnInput`, `DriverContext`, `DriverEvent`, `DriverResult`, `LoomIO`, `PromptInput`, `Surface`, `Plugin`, `SpawnContribution`, `SessionStore`, `ModelResolver`, `ToolProvider`, `SystemPromptBuilder`, `InteractionHandler`, `Catalog`, …
 

package/packages/kernel/dist/contracts/driver.d.ts

@@ -82,6 +82,17 @@ export interface TuiSpec {
     cwd: string;
     env?: Record<string, string>;
 }
+export interface NativeSessionInfo {
+    sessionId: string;
+    title: string | null;
+    preview: string | null;
+    cwd: string | null;
+    model: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    running: boolean;
+    messageCount?: number | null;
+}
 export interface AgentDriver {
     readonly id: string;
     readonly capabilities?: {
@@ -92,4 +103,8 @@ export interface AgentDriver {
     };
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     tui?(input: TuiInput): TuiSpec;
+    listNativeSessions?(opts: {
+        workdir: string;
+        limit?: number;
+    }): NativeSessionInfo[] | Promise<NativeSessionInfo[]>;
 }

package/packages/kernel/dist/contracts/ports.d.ts

@@ -5,9 +5,11 @@ export interface CoreSessionRecord {
     sessionId: string;
     nativeSessionId?: string | null;
     workspacePath: string;
+    workdir?: string | null;
     createdAt: string;
     updatedAt: string;
     title?: string | null;
+    preview?: string | null;
     model?: string | null;
     effort?: string | null;
     runState?: 'running' | 'completed' | 'incomplete';

package/packages/kernel/dist/drivers/claude.d.ts

@@ -1,4 +1,4 @@
-import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, TuiInput, TuiSpec } from '../contracts/driver.js';
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
 import type { UniversalUsage, UniversalPlan } from '../protocol/index.js';
 export declare class ClaudeDriver implements AgentDriver {
     private readonly bin;
@@ -11,6 +11,10 @@ export declare class ClaudeDriver implements AgentDriver {
     };
     constructor(bin?: string);
     tui(input: TuiInput): TuiSpec;
+    listNativeSessions(opts: {
+        workdir: string;
+        limit?: number;
+    }): NativeSessionInfo[];
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     private usage;
 }

package/packages/kernel/dist/drivers/claude.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { discoverClaudeNativeSessions } from '../workspace/native.js';
 // Real driver: shells the local `claude` CLI in stream-json mode and normalizes its
 // events into kernel DriverEvents. Faithful to pikiloom's claude.ts event shapes
 // (system / stream_event{message_start,content_block_delta,message_delta} / assistant / result),
@@ -22,6 +23,9 @@ export class ClaudeDriver {
             args.push(...input.extraArgs);
         return { command: this.bin, args, cwd: input.workdir, env: input.env };
     }
+    listNativeSessions(opts) {
+        return discoverClaudeNativeSessions(opts.workdir, { limit: opts.limit });
+    }
     run(input, ctx) {
         const steerable = !!input.steerable;
         const args = ['-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
@@ -232,6 +236,23 @@ export function handleClaudeEvent(ev, s, emit) {
             s.cacheCreation = u?.cache_creation_input_tokens ?? 0;
             s.output = 0;
         }
+        else if (inner.type === 'content_block_start') {
+            // Claude emits multiple text/thinking blocks per turn (one set per tool-use round). Insert a
+            // paragraph break before a NEW block when prior content exists, so the live preview shows
+            // breaks between segments instead of running them together. Mirrors the legacy driver; the
+            // separator is emitted as a delta so the runtime's accumulated snapshot stays in sync with s.
+            const bt = inner.content_block?.type;
+            if (bt === 'text' && s.text && !s.text.endsWith('\n\n')) {
+                const sep = s.text.endsWith('\n') ? '\n' : '\n\n';
+                s.text += sep;
+                emit({ type: 'text', delta: sep });
+            }
+            else if (bt === 'thinking' && s.reasoning && !s.reasoning.endsWith('\n\n')) {
+                const sep = s.reasoning.endsWith('\n') ? '\n' : '\n\n';
+                s.reasoning += sep;
+                emit({ type: 'reasoning', delta: sep });
+            }
+        }
         else if (inner.type === 'content_block_delta') {
             const d = inner.delta || {};
             if (d.type === 'text_delta' && d.text) {

package/packages/kernel/dist/drivers/codex.d.ts

@@ -1,5 +1,22 @@
-import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, TuiInput, TuiSpec } from '../contracts/driver.js';
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
 import type { UniversalUsage } from '../protocol/index.js';
+export declare function codexToolSummary(item: any): {
+    id: string;
+    name: string;
+    summary: string;
+} | null;
+export interface CodexContentState {
+    text: string;
+    reasoning: string;
+    streamedReasoning: boolean;
+    msgs: string[];
+    thinkParts: string[];
+}
+export declare function codexReasoningItemText(item: any): string;
+export declare function captureCodexAgentMessage(item: any, s: CodexContentState, deltaItems: Set<string>, phases: Map<string, string>, emit: (e: DriverEvent) => void): void;
+export declare function captureCodexReasoning(text: string, s: CodexContentState, emit: (e: DriverEvent) => void): void;
+export declare function codexFinalText(s: CodexContentState): string;
+export declare function codexFinalReasoning(s: CodexContentState): string;
 export declare class CodexDriver implements AgentDriver {
     private readonly bin;
     readonly id = "codex";
@@ -12,6 +29,10 @@ export declare class CodexDriver implements AgentDriver {
     constructor(bin?: string);
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     tui(input: TuiInput): TuiSpec;
+    listNativeSessions(opts: {
+        workdir: string;
+        limit?: number;
+    }): NativeSessionInfo[];
 }
 export interface CodexUsageState {
     input: number | null;

package/packages/kernel/dist/drivers/codex.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { discoverCodexNativeSessions } from '../workspace/native.js';
 // Minimal newline-delimited JSON-RPC client for `codex app-server` (ported faithfully
 // from pikiloom's CodexAppServer; trimmed to what the kernel needs).
 class AppServer {
@@ -20,7 +21,12 @@ class AppServer {
     onServerRequest(cb) { this.requestResponder = cb; }
     async start() {
         const args = ['app-server'];
-        const overrides = this.configOverrides.some(c => /^features\.goals\s*=/.test(c)) ? this.configOverrides : [...this.configOverrides, 'features.goals=true'];
+        // Do NOT force model_reasoning_summary — codex reasoning summaries stay OFF by default
+        // (respecting ~/.codex/config.toml, which is the original behavior). A caller that wants
+        // thinking can pass `model_reasoning_summary=...` via configOverrides; we never inject it.
+        const overrides = [...this.configOverrides];
+        if (!overrides.some(c => /^features\.goals\s*=/.test(c)))
+            overrides.push('features.goals=true');
         for (const c of overrides)
             args.push('-c', c);
         try {
@@ -126,7 +132,12 @@ function codexFileChangeSummary(item) {
 }
 // Normalize a codex app-server item -> {id, name, summary}. The summary mirrors pikiloom's
 // vocabulary ("Run shell: <cmd>", "Edit <path>") so the activity projection reads naturally.
-function codexToolSummary(item) {
+// Only ACTUAL tool calls become Activity rows. agentMessage (the answer text) and reasoning
+// (thinking) are CONTENT — they render below as message text / thinking, never as tools. The old
+// fallback to `item.type` wrongly turned every item (incl. agentMessage/reasoning) into a bogus
+// "tool" in the Activity card. Mirrors the legacy driver's isCodexToolCallItem whitelist.
+const CODEX_TOOL_CALL_TYPES = new Set(['dynamicToolCall', 'mcpToolCall', 'collabAgentToolCall']);
+export function codexToolSummary(item) {
     const id = String(item?.id || '');
     if (!id)
         return null;
@@ -136,8 +147,13 @@ function codexToolSummary(item) {
     }
     if (item.type === 'fileChange' || item.type === 'patch')
         return { id, name: 'edit', summary: codexFileChangeSummary(item) };
-    const tool = typeof item?.tool === 'string' ? item.tool : typeof item?.name === 'string' ? item.name : item?.type;
-    return tool ? { id, name: String(tool), summary: String(tool) } : null;
+    if (CODEX_TOOL_CALL_TYPES.has(item.type)) {
+        const raw = typeof item.tool === 'string' && item.tool.trim() ? item.tool.trim()
+            : typeof item.name === 'string' && item.name.trim() ? item.name.trim() : '';
+        const name = raw ? (raw.split('.').pop() || raw) : 'tool';
+        return { id, name, summary: raw ? `Use ${name}` : 'Use tool' };
+    }
+    return null;
 }
 // codex `item/tool/requestUserInput` params -> a normalized UniversalInteraction
 // (faithful to the legacy codex driver's toAgentInteraction shape).
@@ -160,6 +176,51 @@ function codexUserInputToInteraction(params, promptId) {
         return null;
     return { promptId, kind: 'user-input', title: 'User Input Required', hint: 'Use the buttons when available, or reply with text.', questions };
 }
+// Reasoning text from a completed `reasoning` item (item/completed or rawResponseItem/completed):
+// summary/content arrays of plain strings or {text} objects.
+export function codexReasoningItemText(item) {
+    const parts = [
+        ...(Array.isArray(item?.summary) ? item.summary : []),
+        ...(Array.isArray(item?.content) ? item.content : []),
+    ];
+    return parts.map((p) => (typeof p === 'string' ? p : p?.text || '')).filter(Boolean).join('\n').trim();
+}
+// A completed final_answer agentMessage that did NOT stream deltas: append + emit it live.
+// deltaItems holds the ids already streamed, so a completed item echoing a streamed one is
+// not double-counted (matches the legacy driver's deltaSeenForItem guard).
+export function captureCodexAgentMessage(item, s, deltaItems, phases, emit) {
+    const phase = item?.phase || (item?.id ? phases.get(item.id) : null) || 'final_answer';
+    if (phase !== 'final_answer')
+        return;
+    const text = typeof item?.text === 'string' ? item.text.trim() : '';
+    if (!text)
+        return;
+    s.msgs.push(text);
+    if (item.id && deltaItems.has(item.id))
+        return;
+    const delta = s.text.trim() ? `\n\n${text}` : text;
+    s.text += delta;
+    emit({ type: 'text', delta });
+}
+// A completed reasoning item: keep it for the end-of-turn fallback, and stream it live only
+// when nothing arrived as reasoning deltas (so the streamed path is never double-emitted).
+export function captureCodexReasoning(text, s, emit) {
+    if (!text)
+        return;
+    s.thinkParts.push(text);
+    if (s.streamedReasoning)
+        return;
+    const delta = s.reasoning.trim() ? `\n\n${text}` : text;
+    s.reasoning += delta;
+    emit({ type: 'reasoning', delta });
+}
+// End-of-turn finalizers: prefer streamed text/reasoning, fall back to completed-item parts.
+export function codexFinalText(s) {
+    return s.text.trim() ? s.text : s.msgs.join('\n\n');
+}
+export function codexFinalReasoning(s) {
+    return s.reasoning.trim() ? s.reasoning : s.thinkParts.join('\n\n');
+}
 export class CodexDriver {
     bin;
     id = 'codex';
@@ -173,9 +234,10 @@ export class CodexDriver {
         // to the native account.
         const config = [...(input.configOverrides || [])];
         const srv = new AppServer(this.bin, config, input.env);
-        const state = { text: '', reasoning: '', sessionId: input.sessionId ?? null, input: null, output: null, cached: null, contextUsed: null, contextWindow: null, status: null, error: null, turnId: null };
+        const state = { text: '', reasoning: '', streamedReasoning: false, msgs: [], thinkParts: [], sessionId: input.sessionId ?? null, input: null, output: null, cached: null, contextUsed: null, contextWindow: null, status: null, error: null, turnId: null };
         const phases = new Map();
         const toolSummaries = new Map();
+        const deltaItems = new Set();
         let steerRegistered = false;
         const ok = await srv.start();
         if (!ok)
@@ -239,6 +301,8 @@ export class CodexDriver {
                         const phase = params?.itemId ? (phases.get(params.itemId) || 'final_answer') : 'final_answer';
                         if (phase === 'final_answer' && params?.delta) {
                             state.text += params.delta;
+                            if (params.itemId)
+                                deltaItems.add(params.itemId);
                             ctx.emit({ type: 'text', delta: params.delta });
                         }
                         break;
@@ -247,16 +311,28 @@ export class CodexDriver {
                     case 'item/reasoning/summaryTextDelta':
                         if (params?.delta) {
                             state.reasoning += params.delta;
+                            state.streamedReasoning = true;
                             ctx.emit({ type: 'reasoning', delta: params.delta });
                         }
                         break;
                     case 'item/completed': {
                         const item = params?.item || {};
+                        // Final answer / reasoning delivered as a completed item (no preceding deltas).
+                        if (item.type === 'agentMessage')
+                            captureCodexAgentMessage(item, state, deltaItems, phases, ctx.emit);
+                        else if (item.type === 'reasoning')
+                            captureCodexReasoning(codexReasoningItemText(item), state, ctx.emit);
                         const t = codexToolSummary(item);
                         if (t && toolSummaries.has(t.id))
                             ctx.emit({ type: 'tool', call: { id: t.id, name: t.name, summary: toolSummaries.get(t.id) || t.summary, status: item.status === 'failed' ? 'failed' : 'done' } });
                         break;
                     }
+                    case 'rawResponseItem/completed': {
+                        const item = params?.item || {};
+                        if (item?.type === 'reasoning')
+                            captureCodexReasoning(codexReasoningItemText(item), state, ctx.emit);
+                        break;
+                    }
                     case 'turn/plan/updated': {
                         const plan = planFromUpdate(params);
                         if (plan)
@@ -307,10 +383,11 @@ export class CodexDriver {
             await turnDone;
             const usage = codexUsageOf(state);
             const ok2 = (state.status === 'completed' || state.status == null) && !state.error && !ctx.signal.aborted;
+            const finalReasoning = codexFinalReasoning(state);
             return {
                 ok: ok2,
-                text: state.text,
-                reasoning: state.reasoning || undefined,
+                text: codexFinalText(state),
+                reasoning: finalReasoning || undefined,
                 error: state.error || (ctx.signal.aborted ? 'Interrupted by user.' : null),
                 stopReason: ctx.signal.aborted ? 'interrupted' : (state.status || 'end_turn'),
                 sessionId: state.sessionId,
@@ -329,6 +406,9 @@ export class CodexDriver {
             args.push(...input.extraArgs);
         return { command: this.bin, args, cwd: input.workdir, env: input.env };
     }
+    listNativeSessions(opts) {
+        return discoverCodexNativeSessions(opts.workdir, { limit: opts.limit });
+    }
 }
 const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp']);
 function buildTurnInput(prompt, attachments) {

package/packages/kernel/dist/drivers/gemini.d.ts

@@ -1,4 +1,4 @@
-import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, TuiInput, TuiSpec } from '../contracts/driver.js';
+import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, TuiInput, TuiSpec, NativeSessionInfo } from '../contracts/driver.js';
 export declare class GeminiDriver implements AgentDriver {
     private readonly bin;
     readonly id = "gemini";
@@ -11,6 +11,10 @@ export declare class GeminiDriver implements AgentDriver {
     constructor(bin?: string);
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     tui(input: TuiInput): TuiSpec;
+    listNativeSessions(opts: {
+        workdir: string;
+        limit?: number;
+    }): NativeSessionInfo[];
 }
 export declare function parseGeminiEvent(ev: any, s: any, tools: Map<string, {
     name: string;

package/packages/kernel/dist/drivers/gemini.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { discoverGeminiNativeSessions } from '../workspace/native.js';
 // Native kernel Gemini driver: `gemini --output-format stream-json ... -p <prompt>` and
 // parse its stream-json events into kernel DriverEvents. Faithful to pikiloom's geminiParse.
 export class GeminiDriver {
@@ -80,6 +81,9 @@ export class GeminiDriver {
             args.push(...input.extraArgs);
         return { command: this.bin, args, cwd: input.workdir, env: input.env };
     }
+    listNativeSessions(opts) {
+        return discoverGeminiNativeSessions(opts.workdir, { limit: opts.limit });
+    }
 }
 export function parseGeminiEvent(ev, s, tools, emit) {
     const t = ev.type || '';

package/packages/kernel/dist/index.d.ts

@@ -4,7 +4,7 @@ export { SessionRunner } from './runtime/session-runner.js';
 export { runTurn, type RunTurnOptions, type TurnOutcome } from './runtime/turn.js';
 export { PtyBridge, ptyAvailable, type PtyExit, type PtyOpenOpts } from './runtime/pty.js';
 export { attachTui, type AttachTuiOptions } from './runtime/tui.js';
-export type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, SteerFn, McpServerSpec, TuiInput, TuiSpec, } from './contracts/driver.js';
+export type { AgentDriver, AgentTurnInput, DriverContext, DriverEvent, DriverResult, SteerFn, McpServerSpec, TuiInput, TuiSpec, NativeSessionInfo, } from './contracts/driver.js';
 export type { SessionStore, CoreSessionRecord, ModelResolver, ModelInjection, ToolProvider, SystemPromptBuilder, InteractionHandler, Catalog, } from './contracts/ports.js';
 export type { LoomIO, PromptInput, Surface, SurfaceCapabilities, Plugin, SpawnContribution, } from './contracts/surface.js';
 export { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, AutoCancelInteractionHandler, DeferToTerminalInteractionHandler, NoopCatalog, defaultBaseDir, } from './ports/defaults.js';
@@ -15,4 +15,5 @@ export { GeminiDriver } from './drivers/gemini.js';
 export { HermesDriver } from './drivers/hermes.js';
 export { WebSurface, type WebSurfaceOptions } from './surfaces/web.js';
 export { CliSurface } from './surfaces/cli.js';
+export * from './workspace/index.js';
 export * from './protocol/index.js';

package/packages/kernel/dist/index.js

@@ -25,5 +25,7 @@ export { GeminiDriver } from './drivers/gemini.js';
 export { HermesDriver } from './drivers/hermes.js';
 export { WebSurface } from './surfaces/web.js';
 export { CliSurface } from './surfaces/cli.js';
+// Workspace: unified top-level directory + session/skill/mcp management (loom.paths/sessions/skills/mcp)
+export * from './workspace/index.js';
 // Protocol (the wire vocabulary; shared with transports)
 export * from './protocol/index.js';