@pencil-agent/nano-pencil 1.11.36 → 1.11.37

package/dist/builtin-extensions.js

@@ -20,6 +20,7 @@ const BUNDLED_PRESENCE_EXTENSION = join(__dirname, "extensions", "defaults", "pr
 const BUNDLED_INTERVIEW_EXTENSION = join(__dirname, "extensions", "defaults", "interview", "index.js");
 const BUNDLED_LOOP_EXTENSION = join(__dirname, "extensions", "defaults", "loop", "index.js");
 const BUNDLED_TEAM_EXTENSION = join(__dirname, "extensions", "defaults", "team", "index.js");
+const BUNDLED_SUBAGENT_EXTENSION = join(__dirname, "extensions", "defaults", "subagent", "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");
 /** Find package root from current module location (containing package.json with nano-pencil related name) */
@@ -157,6 +158,15 @@ export function getBuiltinExtensionPaths() {
         if (existsSync(teamTs))
             paths.push(teamTs);
     }
+    // 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 MCP extension
     if (existsSync(BUNDLED_MCP_EXTENSION)) {
         paths.push(BUNDLED_MCP_EXTENSION);

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/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,7 @@
+/**
+ * SubAgent runtime exports.
+ */
+export { SubAgentRuntime, subAgentRuntime } from "./sub-agent-runtime.js";
+export { InProcessSubAgentBackend } from "./sub-agent-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,6 @@
+/**
+ * SubAgent runtime exports.
+ */
+export { SubAgentRuntime, subAgentRuntime } from "./sub-agent-runtime.js";
+export { InProcessSubAgentBackend } from "./sub-agent-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/tools/bash.d.ts

@@ -51,5 +51,16 @@ export declare const bashTool: AgentTool<import("@sinclair/typebox").TObject<{
     command: import("@sinclair/typebox").TString;
     timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>, any>;
+export interface BashSandboxOptions {
+    /** Additional patterns to block (in addition to default blocked patterns) */
+    additionalBlockedPatterns?: RegExp[];
+    /** Custom error message for blocked commands */
+    blockedMessage?: string;
+}
+/**
+ * Create a sandboxed bash hook that blocks dangerous write operations.
+ * This is a defense-in-depth measure for read-only SubAgents.
+ */
+export declare function createSandboxHook(options?: BashSandboxOptions): BashSpawnHook;
 export {};
 //# sourceMappingURL=bash.d.ts.map

package/dist/core/tools/bash.js

@@ -245,4 +245,55 @@ export function createBashTool(cwd, options) {
 }
 /** Default bash tool using process.cwd() - for backwards compatibility */
 export const bashTool = createBashTool(process.cwd());
+/**
+ * Patterns that indicate write operations in bash commands.
+ * These are blocked in sandbox mode.
+ */
+const SANDBOX_BLOCKED_PATTERNS = [
+    // Output redirection
+    /^\s*>|\s>|\s>>|\s&\d>/,
+    // File deletion
+    /\brm\s+/,
+    // Move/copy
+    /\bmv\s+/,
+    /\bcp\s+.*\s+\//,
+    // Git write operations
+    /\bgit\s+(commit|push|pull|add|checkout\s+[^-|]|reset|rebase\s+[^--]|merge)/,
+    // Create directories
+    /\bmkdir\s+[^-]/,
+    // chmod/chown
+    /\bchmod\s+/,
+    /\bchown\s+/,
+    //ln -s
+    /\bln\s+.*-s/,
+    // tee
+    /\btee\s+/,
+    // wget/curl with output
+    /\bwget\s+.*-O/,
+    /\bcurl\s+.*-o/,
+];
+/**
+ * Create a sandboxed bash hook that blocks dangerous write operations.
+ * This is a defense-in-depth measure for read-only SubAgents.
+ */
+export function createSandboxHook(options) {
+    const blockedPatterns = [
+        ...SANDBOX_BLOCKED_PATTERNS,
+        ...(options?.additionalBlockedPatterns ?? []),
+    ];
+    const blockedMessage = options?.blockedMessage ?? "Write operations are not allowed in sandbox mode";
+    return (context) => {
+        const command = context.command.trim();
+        // Check if command contains any blocked patterns
+        for (const pattern of blockedPatterns) {
+            if (pattern.test(command)) {
+                return {
+                    ...context,
+                    command: `echo "${blockedMessage}" >&2; exit 1`,
+                };
+            }
+        }
+        return context;
+    };
+}
 //# sourceMappingURL=bash.js.map

package/dist/core/tools/index.d.ts

@@ -4,7 +4,7 @@
  * [TO]: Consumed by index.ts, main.ts, cli/args.ts, modes/interactive/components/tool-execution.ts, extensions/defaults/team/index.ts, and test files
  * [HERE]: Tool system public API; consumed by SDK and orchestrator
  */
-export { type BashOperations, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, bashTool, createBashTool, } from "./bash.js";
+export { type BashOperations, type BashSandboxOptions, type BashSpawnContext, type BashSpawnHook, type BashToolDetails, type BashToolInput, type BashToolOptions, bashTool, createBashTool, createSandboxHook, } from "./bash.js";
 export { createEditTool, type EditOperations, type EditToolDetails, type EditToolInput, type EditToolOptions, editTool, } from "./edit.js";
 export { createFindTool, type FindOperations, type FindToolDetails, type FindToolInput, type FindToolOptions, findTool, } from "./find.js";
 export { createGrepTool, type GrepOperations, type GrepToolDetails, type GrepToolInput, type GrepToolOptions, grepTool, } from "./grep.js";

package/dist/core/tools/index.js

@@ -4,7 +4,7 @@
  * [TO]: Consumed by index.ts, main.ts, cli/args.ts, modes/interactive/components/tool-execution.ts, extensions/defaults/team/index.ts, and test files
  * [HERE]: Tool system public API; consumed by SDK and orchestrator
  */
-export { bashTool, createBashTool, } from "./bash.js";
+export { bashTool, createBashTool, createSandboxHook, } from "./bash.js";
 export { createEditTool, editTool, } from "./edit.js";
 export { createFindTool, findTool, } from "./find.js";
 export { createGrepTool, grepTool, } from "./grep.js";

package/dist/core/workspace/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Workspace management exports.
+ */
+export { WorktreeManager, worktreeManager } from "./worktree-manager.js";
+export type { WorkspacePath } from "./worktree-manager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/workspace/index.js

@@ -0,0 +1,5 @@
+/**
+ * Workspace management exports.
+ */
+export { WorktreeManager, worktreeManager } from "./worktree-manager.js";
+//# sourceMappingURL=index.js.map

package/dist/core/workspace/worktree-manager.d.ts

@@ -0,0 +1,51 @@
+/**
+ * [UPSTREAM]: Depends on node:fs/promises, node:path
+ * [SURFACE]: WorktreeManager - temporary workspace management
+ * [LOCUS]: core/workspace/worktree-manager.ts
+ */
+export interface WorkspacePath {
+    /** Absolute path to the workspace */
+    readonly path: string;
+    /** Type of workspace */
+    readonly type: "temp" | "worktree";
+}
+/**
+ * Manager for creating and disposing workspaces for SubAgents.
+ * Provides temporary directories and git worktrees.
+ */
+export declare class WorktreeManager {
+    private tempDirs;
+    private worktrees;
+    /**
+     * Create a temporary workspace.
+     * Copies seed files to a new temp directory.
+     * @param seedFiles Files to copy to the temp workspace
+     * @param prefix Prefix for the temp directory name
+     */
+    createTempWorkspace(seedFiles?: string[], prefix?: string): Promise<WorkspacePath>;
+    /**
+     * Create a git worktree for the given branch.
+     * @param branch Branch name for the worktree
+     * @param cwd Working directory for git operations
+     */
+    createGitWorktree(branch?: string, cwd?: string): Promise<WorkspacePath>;
+    /**
+     * Dispose of a workspace.
+     * Removes temp directories and worktrees.
+     * @param workspace The workspace to dispose
+     */
+    dispose(workspace: WorkspacePath): Promise<void>;
+    /**
+     * Get all active temp directories.
+     */
+    getActiveTempDirs(): string[];
+    /**
+     * Clean up all temp directories.
+     */
+    disposeAll(): Promise<void>;
+}
+/**
+ * Default global worktree manager instance.
+ */
+export declare const worktreeManager: WorktreeManager;
+//# sourceMappingURL=worktree-manager.d.ts.map