@pencil-agent/nano-pencil 1.11.36 → 1.11.38

package/dist/builtin-extensions.js

@@ -19,6 +19,8 @@ const BUNDLED_SOUL_EXTENSION = join(__dirname, "extensions", "defaults", "soul",
 const BUNDLED_PRESENCE_EXTENSION = join(__dirname, "extensions", "defaults", "presence", "index.js");
 const BUNDLED_INTERVIEW_EXTENSION = join(__dirname, "extensions", "defaults", "interview", "index.js");
 const BUNDLED_LOOP_EXTENSION = join(__dirname, "extensions", "defaults", "loop", "index.js");
+const BUNDLED_GRUB_EXTENSION = join(__dirname, "extensions", "defaults", "grub", "index.js");
+const BUNDLED_SUBAGENT_EXTENSION = join(__dirname, "extensions", "defaults", "subagent", "index.js");
 const BUNDLED_TEAM_EXTENSION = join(__dirname, "extensions", "defaults", "team", "index.js");
 const BUNDLED_MCP_EXTENSION = join(__dirname, "extensions", "defaults", "mcp", "index.js");
 const BUNDLED_EXPORT_HTML_EXTENSION = join(__dirname, "extensions", "optional", "export-html", "index.js");
@@ -138,7 +140,16 @@ export function getBuiltinExtensionPaths() {
         if (existsSync(interviewTs))
             paths.push(interviewTs);
     }
-    // === Loop extension (/grub autonomous task, /loop scheduler) ===
+    // === Grub extension (/grub autonomous iterative task) ===
+    if (existsSync(BUNDLED_GRUB_EXTENSION)) {
+        paths.push(BUNDLED_GRUB_EXTENSION);
+    }
+    else {
+        const grubTs = join(__dirname, "extensions", "defaults", "grub", "index.ts");
+        if (existsSync(grubTs))
+            paths.push(grubTs);
+    }
+    // === Loop extension (/loop recurring scheduler) ===
     if (existsSync(BUNDLED_LOOP_EXTENSION)) {
         paths.push(BUNDLED_LOOP_EXTENSION);
     }
@@ -148,7 +159,16 @@ export function getBuiltinExtensionPaths() {
             paths.push(loopTs);
     }
     // === MCP extension (MCP tool protocol adapter) ===
-    // Built-in team extension
+    // Built-in SubAgent extension
+    if (existsSync(BUNDLED_SUBAGENT_EXTENSION)) {
+        paths.push(BUNDLED_SUBAGENT_EXTENSION);
+    }
+    else {
+        const subagentTs = join(__dirname, "extensions", "defaults", "subagent", "index.ts");
+        if (existsSync(subagentTs))
+            paths.push(subagentTs);
+    }
+    // Built-in AgentTeam extension (Phase B - persistent teammates)
     if (existsSync(BUNDLED_TEAM_EXTENSION)) {
         paths.push(BUNDLED_TEAM_EXTENSION);
     }

package/dist/core/config/settings-manager.d.ts

@@ -97,6 +97,10 @@ export interface Settings {
             lockStaleMinutes?: number;
         };
     };
+    /** Presence extension settings - AI greeting and idle messages */
+    presence?: {
+        enabled?: boolean;
+    };
     /** Auto-update setting: 'always' = auto-update on startup, 'prompt' = ask user (default), 'never' = never check */
     autoUpdate?: "always" | "prompt" | "never";
     /** Last skipped version for update prompts */
@@ -240,6 +244,8 @@ export declare class SettingsManager {
     setShowWorkingTrace(enabled: boolean): void;
     getShowMemoryTrace(): boolean;
     setShowMemoryTrace(enabled: boolean): void;
+    getPresenceEnabled(): boolean;
+    setPresenceEnabled(enabled: boolean): void;
     getImageAutoResize(): boolean;
     setImageAutoResize(enabled: boolean): void;
     getBlockImages(): boolean;

package/dist/core/config/settings-manager.js

@@ -624,6 +624,17 @@ export class SettingsManager {
         this.markModified("terminal", "showMemoryTrace");
         this.save();
     }
+    getPresenceEnabled() {
+        return this.settings.presence?.enabled ?? true;
+    }
+    setPresenceEnabled(enabled) {
+        if (!this.globalSettings.presence) {
+            this.globalSettings.presence = {};
+        }
+        this.globalSettings.presence.enabled = enabled;
+        this.markModified("presence", "enabled");
+        this.save();
+    }
     getImageAutoResize() {
         return this.settings.images?.autoResize ?? true;
     }

package/dist/core/i18n/messages.d.ts

@@ -49,5 +49,9 @@ export declare const messages: {
     confirmQuit: string;
     confirmNewSession: string;
     confirmDelete: string;
+    presence: {
+        opening: string[];
+        idle: string[];
+    };
 };
 //# sourceMappingURL=messages.d.ts.map

package/dist/core/i18n/messages.js

@@ -58,5 +58,22 @@ export const messages = {
     confirmQuit: "Are you sure you want to quit?",
     confirmNewSession: "Start a new session? Current session will be saved.",
     confirmDelete: "Are you sure you want to delete?",
+    // Presence (AI generation fails or memory is empty - fallback messages)
+    presence: {
+        opening: [
+            "Hey, what's up?",
+            "Ready when you are.",
+            "What do you want to work on?",
+            "Any ideas?",
+            "Let's do this.",
+        ],
+        idle: [
+            "Still here when you need me.",
+            "No rush, take your time.",
+            "Ready when you are.",
+            "I'll be here.",
+            "Whenever you're ready.",
+        ],
+    },
 };
 //# sourceMappingURL=messages.js.map

package/dist/core/i18n/messages.zh.d.ts

@@ -49,5 +49,9 @@ export declare const messages: {
     confirmQuit: string;
     confirmNewSession: string;
     confirmDelete: string;
+    presence: {
+        opening: string[];
+        idle: string[];
+    };
 };
 //# sourceMappingURL=messages.zh.d.ts.map

package/dist/core/i18n/messages.zh.js

@@ -58,5 +58,22 @@ export const messages = {
     confirmQuit: "确定要退出吗？",
     confirmNewSession: "开始新会话？当前会话将被保存。",
     confirmDelete: "确定要删除吗？",
+    // Presence (AI生成失败或记忆为空时的备用消息)
+    presence: {
+        opening: [
+            "来了啊。",
+            "嘿，有什么想做的吗？",
+            "准备开始吧。",
+            "随时可以开始。",
+            "有什么要聊聊的吗？",
+        ],
+        idle: [
+            "还在，有需要随时说。",
+            "不急，慢慢来。",
+            "我在，随时继续。",
+            "有空了就继续吧。",
+            "没关系的，想什么时候继续都行。",
+        ],
+    },
 };
 //# sourceMappingURL=messages.zh.js.map

package/dist/core/i18n/slash-commands.d.ts

@@ -28,6 +28,7 @@ export declare const slashCommands: {
     logout: string;
     new: string;
     update: string;
+    reinstall: string;
     compact: string;
     resume: string;
     reload: string;

package/dist/core/i18n/slash-commands.js

@@ -28,6 +28,7 @@ export const slashCommands = {
     logout: "Logout from OAuth provider",
     new: "Start a new session",
     update: "Check for NanoPencil updates",
+    reinstall: "Force reinstall NanoPencil (clean install)",
     compact: "Manually compact the session context",
     resume: "Resume a different session",
     reload: "Reload extensions, skills, prompts, and themes",

package/dist/core/i18n/slash-commands.zh.d.ts

@@ -28,6 +28,7 @@ export declare const slashCommands: {
     logout: string;
     new: string;
     update: string;
+    reinstall: string;
     compact: string;
     resume: string;
     reload: string;

package/dist/core/i18n/slash-commands.zh.js

@@ -28,6 +28,7 @@ export const slashCommands = {
     logout: "从 OAuth 提供商登出",
     new: "开始新会话",
     update: "检查 NanoPencil 更新",
+    reinstall: "强制重新安装 NanoPencil（干净安装）",
     compact: "手动压缩会话上下文",
     resume: "恢复其他会话",
     reload: "重新加载扩展、技能、提示和主题",

package/dist/core/package-manager.js

@@ -69,7 +69,9 @@ function addIgnoreRules(ig, dir, rootDir) {
                 ig.add(patterns);
             }
         }
-        catch { }
+        catch (e) {
+            console.warn("Warning: Failed to read ignore file:", e instanceof Error ? e.message : e);
+        }
     }
 }
 function isPattern(s) {

package/dist/core/runtime/agent-session.d.ts

@@ -90,6 +90,8 @@ export interface AgentSessionConfig {
     extensionRunnerRef?: {
         current?: ExtensionRunner;
     };
+    /** External abort signal for stopping the session (e.g., from SubAgent runtime) */
+    signal?: AbortSignal;
 }
 export interface ExtensionBindings {
     uiContext?: ExtensionUIContext;

package/dist/core/runtime/agent-session.js

@@ -154,6 +154,12 @@ export class AgentSession {
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
+        // Listen to external abort signal (e.g., from SubAgent runtime)
+        if (config.signal) {
+            config.signal.addEventListener("abort", () => {
+                this.abort();
+            });
+        }
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,

package/dist/core/runtime/sdk.d.ts

@@ -40,6 +40,8 @@ export interface CreateAgentSessionOptions {
     sessionManager?: SessionManager;
     /** Settings manager. Default: SettingsManager.create(cwd, agentDir) */
     settingsManager?: SettingsManager;
+    /** External abort signal for stopping the session (e.g., from SubAgent runtime) */
+    signal?: AbortSignal;
 }
 /** Result from createAgentSession */
 export interface CreateAgentSessionResult {

package/dist/core/runtime/sdk.js

@@ -350,6 +350,7 @@ export async function createAgentSession(options = {}) {
         extensionRunnerRef,
         soulManager,
         soulManagerFactory,
+        signal: options.signal,
     });
     const extensionsResult = resourceLoader.getExtensions();
     return {

package/dist/core/skills.js

@@ -56,7 +56,9 @@ function addIgnoreRules(ig, dir, rootDir) {
                 ig.add(patterns);
             }
         }
-        catch { }
+        catch (e) {
+            console.warn("Warning: Failed to read ignore file:", e instanceof Error ? e.message : e);
+        }
     }
 }
 /**
@@ -166,7 +168,9 @@ function loadSkillsFromDirInternal(dir, source, includeRootFiles, ignoreMatcher,
             diagnostics.push(...result.diagnostics);
         }
     }
-    catch { }
+    catch (e) {
+        console.warn("Warning: Failed to read skills directory:", e instanceof Error ? e.message : e);
+    }
     return { skills, diagnostics };
 }
 function loadSkillFromFile(filePath, source) {

package/dist/core/slash-commands.js

@@ -22,6 +22,7 @@ export const BUILTIN_SLASH_COMMANDS = [
     { name: "logout", descriptionKey: "slash.logout" },
     { name: "new", descriptionKey: "slash.new" },
     { name: "update", descriptionKey: "slash.update" },
+    { name: "reinstall", descriptionKey: "slash.reinstall" },
     { name: "compact", descriptionKey: "slash.compact" },
     { name: "resume", descriptionKey: "slash.resume" },
     { name: "reload", descriptionKey: "slash.reload" },

package/dist/core/sub-agent/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SubAgent runtime exports.
+ */
+export { SubAgentRuntime, subAgentRuntime } from "./sub-agent-runtime.js";
+export { InProcessSubAgentBackend } from "./sub-agent-backend.js";
+export { SubprocessSubAgentBackend } from "./subprocess-backend.js";
+export type { SubprocessBackendOptions } from "./subprocess-backend.js";
+export type { SubAgentSpec, SubAgentResult, SubAgentHandle, SubAgentBackend, } from "./sub-agent-types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/sub-agent/index.js

@@ -0,0 +1,7 @@
+/**
+ * SubAgent runtime exports.
+ */
+export { SubAgentRuntime, subAgentRuntime } from "./sub-agent-runtime.js";
+export { InProcessSubAgentBackend } from "./sub-agent-backend.js";
+export { SubprocessSubAgentBackend } from "./subprocess-backend.js";
+//# sourceMappingURL=index.js.map

package/dist/core/sub-agent/sub-agent-backend.d.ts

@@ -0,0 +1,14 @@
+/**
+ * [UPSTREAM]: Depends on sub-agent-types.ts, core/runtime/sdk.ts
+ * [SURFACE]: InProcessSubAgentBackend
+ * [LOCUS]: core/sub-agent/sub-agent-backend.ts
+ */
+import type { SubAgentBackend, SubAgentHandle, SubAgentSpec } from "./sub-agent-types.js";
+/**
+ * In-process SubAgent backend.
+ * Wraps createAgentSession() to run SubAgent in the same process.
+ */
+export declare class InProcessSubAgentBackend implements SubAgentBackend {
+    spawn(spec: SubAgentSpec): Promise<SubAgentHandle>;
+}
+//# sourceMappingURL=sub-agent-backend.d.ts.map

package/dist/core/sub-agent/sub-agent-backend.js

@@ -0,0 +1,119 @@
+/**
+ * [UPSTREAM]: Depends on sub-agent-types.ts, core/runtime/sdk.ts
+ * [SURFACE]: InProcessSubAgentBackend
+ * [LOCUS]: core/sub-agent/sub-agent-backend.ts
+ */
+import { createAgentSession } from "../runtime/sdk.js";
+/**
+ * In-process SubAgent backend.
+ * Wraps createAgentSession() to run SubAgent in the same process.
+ */
+export class InProcessSubAgentBackend {
+    async spawn(spec) {
+        const id = crypto.randomUUID();
+        // Create an internal AbortController that can be triggered by external signal or timeout
+        const internalAbortController = new AbortController();
+        // Forward external signal abort to internal controller
+        const signalHandler = () => {
+            if (!internalAbortController.signal.aborted) {
+                internalAbortController.abort();
+            }
+        };
+        spec.signal.addEventListener("abort", signalHandler);
+        // Create agent session with our internal signal
+        const options = {
+            cwd: spec.cwd,
+            tools: spec.tools,
+            signal: internalAbortController.signal,
+            model: spec.model,
+        };
+        const { session } = await createAgentSession(options);
+        const timeoutMs = spec.timeoutMs;
+        let status = "running";
+        let result;
+        // Set up timeout if specified
+        let timeoutId;
+        if (timeoutMs !== undefined) {
+            timeoutId = setTimeout(() => {
+                if (status === "running") {
+                    internalAbortController.abort();
+                }
+            }, timeoutMs);
+        }
+        // Extract text from assistant message content
+        const extractTextFromContent = (content) => {
+            if (typeof content === "string")
+                return content;
+            if (Array.isArray(content)) {
+                return content
+                    .filter((part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && typeof part.text === "string")
+                    .map((part) => part.text)
+                    .join("\n");
+            }
+            return "";
+        };
+        // Start the prompt
+        const promptPromise = (async () => {
+            try {
+                await session.prompt(spec.prompt, {
+                    images: spec.images,
+                });
+                status = "done";
+                // Extract the last assistant message as the result
+                const messages = session.messages ?? [];
+                const assistantMessages = messages.filter((m) => m.role === "assistant");
+                const lastAssistant = assistantMessages[assistantMessages.length - 1];
+                const responseText = lastAssistant ? extractTextFromContent(lastAssistant.content) : "";
+                result = {
+                    success: true,
+                    response: responseText,
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "AbortError") {
+                    status = "aborted";
+                    result = {
+                        success: false,
+                        error: "Aborted",
+                    };
+                }
+                else {
+                    status = "error";
+                    result = {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            finally {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+                // Clean up signal handler
+                spec.signal.removeEventListener("abort", signalHandler);
+            }
+        })();
+        return {
+            id,
+            get status() {
+                return status;
+            },
+            async result() {
+                await promptPromise;
+                return (result ?? {
+                    success: false,
+                    error: "No result available",
+                });
+            },
+            async abort() {
+                internalAbortController.abort();
+                await session.abort();
+            },
+            async terminate() {
+                internalAbortController.abort();
+                await session.abort();
+            },
+        };
+    }
+}
+//# sourceMappingURL=sub-agent-backend.js.map

package/dist/core/sub-agent/sub-agent-runtime.d.ts

@@ -0,0 +1,38 @@
+/**
+ * [UPSTREAM]: Depends on sub-agent-types.ts, sub-agent-backend.ts
+ * [SURFACE]: SubAgentRuntime - spawn, abort, lifecycle management
+ * [LOCUS]: core/sub-agent/sub-agent-runtime.ts
+ */
+import type { SubAgentBackend, SubAgentHandle, SubAgentSpec } from "./sub-agent-types.js";
+/**
+ * Runtime for managing SubAgents.
+ * Provides spawn/abort/lifecycle operations.
+ */
+export declare class SubAgentRuntime {
+    private backend;
+    private activeAgents;
+    constructor(backend?: SubAgentBackend);
+    /**
+     * Spawn a new SubAgent with the given specification.
+     * @param spec The SubAgent specification
+     * @returns A handle to the spawned SubAgent
+     */
+    spawn(spec: SubAgentSpec): Promise<SubAgentHandle>;
+    /**
+     * Get all active SubAgent handles.
+     */
+    getActiveAgents(): SubAgentHandle[];
+    /**
+     * Abort all active SubAgents.
+     */
+    abortAll(): Promise<void>;
+    /**
+     * Terminate all active SubAgents.
+     */
+    terminateAll(): Promise<void>;
+}
+/**
+ * Default global SubAgent runtime instance.
+ */
+export declare const subAgentRuntime: SubAgentRuntime;
+//# sourceMappingURL=sub-agent-runtime.d.ts.map

package/dist/core/sub-agent/sub-agent-runtime.js

@@ -0,0 +1,54 @@
+/**
+ * [UPSTREAM]: Depends on sub-agent-types.ts, sub-agent-backend.ts
+ * [SURFACE]: SubAgentRuntime - spawn, abort, lifecycle management
+ * [LOCUS]: core/sub-agent/sub-agent-runtime.ts
+ */
+import { InProcessSubAgentBackend } from "./sub-agent-backend.js";
+/**
+ * Runtime for managing SubAgents.
+ * Provides spawn/abort/lifecycle operations.
+ */
+export class SubAgentRuntime {
+    backend;
+    activeAgents = new Map();
+    constructor(backend = new InProcessSubAgentBackend()) {
+        this.backend = backend;
+    }
+    /**
+     * Spawn a new SubAgent with the given specification.
+     * @param spec The SubAgent specification
+     * @returns A handle to the spawned SubAgent
+     */
+    async spawn(spec) {
+        const handle = await this.backend.spawn(spec);
+        this.activeAgents.set(handle.id, handle);
+        // Clean up when the agent finishes
+        handle.result().finally(() => {
+            this.activeAgents.delete(handle.id);
+        });
+        return handle;
+    }
+    /**
+     * Get all active SubAgent handles.
+     */
+    getActiveAgents() {
+        return Array.from(this.activeAgents.values());
+    }
+    /**
+     * Abort all active SubAgents.
+     */
+    async abortAll() {
+        await Promise.all(Array.from(this.activeAgents.values()).map((agent) => agent.abort()));
+    }
+    /**
+     * Terminate all active SubAgents.
+     */
+    async terminateAll() {
+        await Promise.all(Array.from(this.activeAgents.values()).map((agent) => agent.terminate()));
+    }
+}
+/**
+ * Default global SubAgent runtime instance.
+ */
+export const subAgentRuntime = new SubAgentRuntime();
+//# sourceMappingURL=sub-agent-runtime.js.map

package/dist/core/sub-agent/sub-agent-types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * [UPSTREAM]: Depends on core/runtime/sdk.ts, core/tools/*
+ * [SURFACE]: SubAgentSpec, SubAgentHandle, SubAgentBackend
+ * [LOCUS]: core/sub-agent/sub-agent-types.ts
+ * [COVENANT]: Change these types → update P1 architecture diagram
+ */
+import type { ImageContent, Model } from "@pencil-agent/ai";
+import type { Tool } from "../tools/index.js";
+/**
+ * Specification for spawning a SubAgent.
+ */
+export interface SubAgentSpec {
+    /** Task prompt for the SubAgent */
+    prompt: string;
+    /** Tools available to the SubAgent (determined by caller, not guessed by core) */
+    tools: Tool[];
+    /** Working directory for the SubAgent (can be a worktree) */
+    cwd: string;
+    /** Abort signal for stopping the SubAgent (required) */
+    signal: AbortSignal;
+    /** Optional timeout in milliseconds */
+    timeoutMs?: number;
+    /** Images to include in the prompt */
+    images?: ImageContent[];
+    /** Model to use (reuses main session's model and auth) */
+    model?: Model<any>;
+}
+/**
+ * Result from a completed SubAgent run.
+ */
+export interface SubAgentResult {
+    /** Whether the run was successful */
+    success: boolean;
+    /** The response text from the SubAgent */
+    response?: string;
+    /** Error message if unsuccessful */
+    error?: string;
+}
+/**
+ * Handle to a running SubAgent.
+ */
+export interface SubAgentHandle {
+    /** Unique identifier for this SubAgent */
+    readonly id: string;
+    /** Current status of the SubAgent */
+    readonly status: "running" | "done" | "aborted" | "error";
+    /**
+     * Wait for the SubAgent to complete and get its result.
+     * Resolves when the SubAgent finishes (successfully or with error).
+     */
+    result(): Promise<SubAgentResult>;
+    /**
+     * Abort the current turn (stops after current LLM response).
+     * The SubAgent may still be in "running" state if it can accept more turns.
+     */
+    abort(): Promise<void>;
+    /**
+     * Terminate the SubAgent completely.
+     * This stops all work and disposes of resources.
+     */
+    terminate(): Promise<void>;
+}
+/**
+ * Backend for spawning SubAgents.
+ * Core provides in-process backend; subprocess backend can be added in phase B.
+ */
+export interface SubAgentBackend {
+    /**
+     * Spawn a new SubAgent with the given specification.
+     * @param spec The SubAgent specification
+     * @returns A handle to the spawned SubAgent
+     */
+    spawn(spec: SubAgentSpec): Promise<SubAgentHandle>;
+}
+//# sourceMappingURL=sub-agent-types.d.ts.map

package/dist/core/sub-agent/sub-agent-types.js

@@ -0,0 +1,8 @@
+/**
+ * [UPSTREAM]: Depends on core/runtime/sdk.ts, core/tools/*
+ * [SURFACE]: SubAgentSpec, SubAgentHandle, SubAgentBackend
+ * [LOCUS]: core/sub-agent/sub-agent-types.ts
+ * [COVENANT]: Change these types → update P1 architecture diagram
+ */
+export {};
+//# sourceMappingURL=sub-agent-types.js.map

package/dist/core/sub-agent/subprocess-backend.d.ts

@@ -0,0 +1,36 @@
+/**
+ * [WHO]: SubprocessSubAgentBackend
+ * [FROM]: Depends on node:worker_threads, ./sub-agent-types
+ * [TO]: Consumed by SubAgentRuntime when caller wants crash isolation
+ * [HERE]: core/sub-agent/subprocess-backend.ts - Phase B B.6 multi-backend
+ *
+ * Crash-isolated SubAgent backend built on top of node:worker_threads.
+ *
+ * The worker thread runs the in-process backend in its own V8 isolate, so
+ * an unhandled error inside a teammate cannot tear down the main session.
+ * The Tool[] surface in `SubAgentSpec` is NOT serializable across the
+ * worker boundary, so the caller must pre-stage tools by name and resolve
+ * them inside the worker via `toolFactoryName`. For v1 we accept the same
+ * profiles the team extension already uses ("read-only" / "sandboxed").
+ *
+ * Status: SHIPPED with the worker harness in place; the worker entry
+ * itself is intentionally minimal (echo + abort) so the interface is real
+ * and exercisable. The full agent loop inside the worker is deferred to a
+ * follow-up because it requires re-creating the model registry inside the
+ * isolate, which is out of scope for the AgentTeam Phase B milestone.
+ *
+ * The backend therefore documents itself honestly: callers that need real
+ * LLM execution should keep using `InProcessSubAgentBackend`; callers that
+ * just need an isolated bash/echo worker can use this one today.
+ */
+import type { SubAgentBackend, SubAgentHandle, SubAgentSpec } from "./sub-agent-types.js";
+export interface SubprocessBackendOptions {
+    /** Override the worker entry path (for tests). */
+    workerEntry?: string;
+}
+export declare class SubprocessSubAgentBackend implements SubAgentBackend {
+    private readonly workerEntry;
+    constructor(options?: SubprocessBackendOptions);
+    spawn(spec: SubAgentSpec): Promise<SubAgentHandle>;
+}
+//# sourceMappingURL=subprocess-backend.d.ts.map