@jitsusama/agentic-harness.core 0.1.0

package/dist/internal/terminal/drivers/tmux.js

@@ -0,0 +1,88 @@
+/**
+ * Tmux driver. Uses `tmux new-window` for tabs and windows
+ * (tmux has no separate window concept; a new tmux "window"
+ * is what we call a tab), and `tmux split-window` for panes.
+ *
+ * Available when both:
+ *
+ * - The `tmux` binary is on PATH.
+ * - The current process is inside a tmux session (`TMUX`
+ *   env var is set). Otherwise the new tab has nowhere to
+ *   attach.
+ */
+import { execFile, spawn as nodeSpawn } from "node:child_process";
+import { promisify } from "node:util";
+import { wrapCommandWithEnv } from "./shared.js";
+const execFileAsync = promisify(execFile);
+async function tmuxOnPath() {
+    try {
+        await execFileAsync("command", ["-v", "tmux"]);
+        return true;
+    }
+    catch {
+        try {
+            await execFileAsync("which", ["tmux"]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function buildArgs(request) {
+    const args = [];
+    switch (request.layout) {
+        case "tab":
+        case "window":
+            // Tmux's "window" is what other emulators call a
+            // tab. There is no native multi-window concept;
+            // callers asking for a window get a new tab.
+            args.push("new-window");
+            if (request.title)
+                args.push("-n", request.title);
+            if (request.cwd)
+                args.push("-c", request.cwd);
+            break;
+        case "pane":
+            args.push("split-window");
+            if (request.cwd)
+                args.push("-c", request.cwd);
+            break;
+    }
+    // Tmux runs the spawned command in the server's
+    // environment, not the calling CLI's. Wrapping the
+    // command in a shell that sets env vars and execs
+    // the target is portable across tmux versions and
+    // avoids relying on `-e KEY=value`, which was added
+    // in tmux 3.0 and not always present.
+    // No command means the caller wants the surface itself, so let
+    // tmux start the user's own login shell: that is the only way the
+    // shell's startup files run.
+    if (request.command === undefined)
+        return args;
+    args.push(wrapCommandWithEnv(request.command, request.env));
+    return args;
+}
+export const tmux = {
+    id: "tmux",
+    async available() {
+        if (!process.env.TMUX)
+            return false;
+        return tmuxOnPath();
+    },
+    async spawn(request) {
+        const args = buildArgs(request);
+        await new Promise((resolve, reject) => {
+            const child = nodeSpawn("tmux", args, {
+                stdio: "ignore",
+            });
+            child.on("error", reject);
+            child.on("exit", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`tmux exited with code ${code}`));
+            });
+        });
+    },
+};

package/dist/internal/terminal/drivers/wezterm.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Wezterm driver. Uses `wezterm cli spawn` to launch new
+ * tabs and windows, and `wezterm cli split-pane` for panes.
+ *
+ * Available when the `wezterm` binary is on PATH. We don't
+ * verify that wezterm is the active terminal: the `cli`
+ * subcommand connects to the running mux over a socket, so
+ * it works from anywhere as long as wezterm itself is
+ * running somewhere reachable.
+ */
+import { type TerminalDriver, type TerminalLivenessCapability, type TerminalProbe, type TerminalSessionHandle, type TerminalTypeCapability } from "../../../terminal/types.js";
+/** What a `wezterm cli list` read observed, or that it could not read. */
+export type WeztermObservation = {
+    reachable: false;
+} | {
+    reachable: true;
+    hostId: string;
+    scope: string;
+    livePaneIds: ReadonlySet<string>;
+};
+/**
+ * Classify each recorded pane handle against a live observation. A
+ * pane is present or absent only when the observation is reachable
+ * and the handle's host and scope match the observed mux; otherwise
+ * the honest answer is unknown, because a pane id is meaningful only
+ * within the socket and host that issued it.
+ */
+export declare function classifyWeztermPanes(handles: readonly TerminalSessionHandle[], observation: WeztermObservation): Map<string, TerminalProbe>;
+/**
+ * The pane id `wezterm cli spawn` prints, or undefined when the
+ * output is not one. The cli prints the new pane id on stdout,
+ * which is the only reliable way to name what was just created.
+ */
+export declare function paneIdFromSpawn(stdout: string): string | undefined;
+export declare const wezterm: TerminalDriver & TerminalLivenessCapability & TerminalTypeCapability;

package/dist/internal/terminal/drivers/wezterm.js

@@ -0,0 +1,175 @@
+/**
+ * Wezterm driver. Uses `wezterm cli spawn` to launch new
+ * tabs and windows, and `wezterm cli split-pane` for panes.
+ *
+ * Available when the `wezterm` binary is on PATH. We don't
+ * verify that wezterm is the active terminal: the `cli`
+ * subcommand connects to the running mux over a socket, so
+ * it works from anywhere as long as wezterm itself is
+ * running somewhere reachable.
+ */
+import { execFile } from "node:child_process";
+import { hostname } from "node:os";
+import { promisify } from "node:util";
+import { terminalHandleKey, } from "../../../terminal/types.js";
+import { wrapCommandWithEnv } from "./shared.js";
+/**
+ * Classify each recorded pane handle against a live observation. A
+ * pane is present or absent only when the observation is reachable
+ * and the handle's host and scope match the observed mux; otherwise
+ * the honest answer is unknown, because a pane id is meaningful only
+ * within the socket and host that issued it.
+ */
+export function classifyWeztermPanes(handles, observation) {
+    const out = new Map();
+    for (const handle of handles) {
+        out.set(terminalHandleKey(handle), classifyOne(handle, observation));
+    }
+    return out;
+}
+function classifyOne(handle, observation) {
+    if (!observation.reachable)
+        return "unknown";
+    if (handle.hostId !== observation.hostId)
+        return "unknown";
+    if (!handle.scope || handle.scope !== observation.scope)
+        return "unknown";
+    return observation.livePaneIds.has(handle.value) ? "present" : "absent";
+}
+const execFileAsync = promisify(execFile);
+async function isOnPath(binary) {
+    try {
+        await execFileAsync("command", ["-v", binary]);
+        return true;
+    }
+    catch {
+        try {
+            await execFileAsync("which", [binary]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function buildArgs(request) {
+    const args = ["cli"];
+    switch (request.layout) {
+        case "tab":
+            args.push("spawn");
+            break;
+        case "window":
+            args.push("spawn", "--new-window");
+            break;
+        case "pane":
+            args.push("split-pane");
+            break;
+    }
+    if (request.cwd)
+        args.push("--cwd", request.cwd);
+    // No command means the caller wants the surface itself: let
+    // wezterm start the user's own login shell, which is the only way
+    // the shell's startup files run. Handing even a trivial command to
+    // `-c` skips them.
+    if (request.command === undefined)
+        return args;
+    // `wezterm cli` hands the command to the mux daemon,
+    // which runs it in the daemon's own environment. The
+    // Node-side env on `nodeSpawn` reaches only the cli
+    // process itself, not the new pane, so env that must
+    // reach the pane has to be wrapped into the command.
+    const command = wrapCommandWithEnv(request.command, request.env);
+    args.push("--", "/bin/sh", "-c", command);
+    return args;
+}
+/**
+ * The pane id `wezterm cli spawn` prints, or undefined when the
+ * output is not one. The cli prints the new pane id on stdout,
+ * which is the only reliable way to name what was just created.
+ */
+export function paneIdFromSpawn(stdout) {
+    const trimmed = stdout.trim();
+    return /^\d+$/.test(trimmed) ? trimmed : undefined;
+}
+export const wezterm = {
+    id: "wezterm",
+    async available() {
+        return isOnPath("wezterm");
+    },
+    async spawn(request) {
+        const args = buildArgs(request);
+        // Wait for the cli to finish rather than detaching, so its
+        // stdout can be read: it prints the new pane id, and without
+        // that the caller has no way to name what it just created. The
+        // cli returns as soon as the mux has spawned the pane, so this
+        // does not wait on the pane's own lifetime.
+        try {
+            const { stdout } = await execFileAsync("wezterm", args);
+            const pane = paneIdFromSpawn(stdout);
+            if (!pane)
+                return undefined;
+            return {
+                driverId: "wezterm",
+                kind: "wezterm-pane",
+                hostId: hostname(),
+                value: pane,
+                ...(process.env.WEZTERM_UNIX_SOCKET
+                    ? { scope: process.env.WEZTERM_UNIX_SOCKET }
+                    : {}),
+            };
+        }
+        catch (error) {
+            // A spawn that failed is worth reporting: the caller asked for
+            // a surface and has not got one.
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+    },
+    async typeInto(handle, text) {
+        // --no-paste sends the text as individual keystrokes rather than
+        // a bracketed paste, so the shell treats it as typed input and
+        // runs it on the newline.
+        await execFileAsync("wezterm", ["cli", "send-text", "--pane-id", handle.value, "--no-paste", text], { env: process.env });
+    },
+    identifyCurrent() {
+        const pane = process.env.WEZTERM_PANE;
+        if (!pane)
+            return undefined;
+        return {
+            driverId: "wezterm",
+            kind: "wezterm-pane",
+            hostId: hostname(),
+            scope: process.env.WEZTERM_UNIX_SOCKET,
+            value: pane,
+        };
+    },
+    async probe(handles, signal) {
+        const observation = await observePanes(signal);
+        return classifyWeztermPanes(handles, observation);
+    },
+};
+/** Read the live pane set from the wezterm mux, or report it unreachable. */
+async function observePanes(signal) {
+    const socket = process.env.WEZTERM_UNIX_SOCKET;
+    if (!socket)
+        return { reachable: false };
+    try {
+        const { stdout } = await execFileAsync("wezterm", ["cli", "list", "--format", "json"], { signal });
+        const panes = JSON.parse(stdout);
+        const live = new Set();
+        for (const pane of panes) {
+            if (typeof pane.pane_id === "number")
+                live.add(String(pane.pane_id));
+        }
+        return {
+            reachable: true,
+            hostId: hostname(),
+            scope: socket,
+            livePaneIds: live,
+        };
+    }
+    catch {
+        // Mux unreachable, wezterm absent, or unparseable output: an
+        // observation failure is unknown, never a false absent.
+        return { reachable: false };
+    }
+}

package/dist/internal/terminal/registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Terminal driver registry: process-global map from driver
+ * id to `TerminalDriver`. Symmetric with refs and tree
+ * registries; uses the shared `createGlobalSymbolRegistry`
+ * helper.
+ */
+import type { TerminalDriver } from "../../terminal/types.js";
+export declare const register: (driver: TerminalDriver) => void;
+export declare const unregister: (id: string) => void;
+export declare const clear: () => void;
+export declare const get: (id: string) => TerminalDriver | undefined;
+export declare const list: () => TerminalDriver[];

package/dist/internal/terminal/registry.js

@@ -0,0 +1,16 @@
+/**
+ * Terminal driver registry: process-global map from driver
+ * id to `TerminalDriver`. Symmetric with refs and tree
+ * registries; uses the shared `createGlobalSymbolRegistry`
+ * helper.
+ */
+import { createGlobalSymbolRegistry } from "../registry/global-symbol-registry.js";
+const registry = createGlobalSymbolRegistry({
+    slot: "pi:agentic-harness:terminal-drivers",
+    getId: (d) => d.id,
+});
+export const register = (driver) => registry.register(driver);
+export const unregister = (id) => registry.unregister(id);
+export const clear = () => registry.clear();
+export const get = (id) => registry.get(id);
+export const list = () => registry.list();

package/dist/internal/tree/builtins.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Built-in tree providers. Seeded via
+ * `registerBuiltinTreeProviders`; downstream packages
+ * register their own at lower priority numbers to take
+ * over for specific repo roots.
+ */
+import type { TreeProvider } from "../../tree/types.js";
+export declare const BUILTIN_TREE_PROVIDERS: TreeProvider[];

package/dist/internal/tree/builtins.js

@@ -0,0 +1,10 @@
+/**
+ * Built-in tree providers. Seeded via
+ * `registerBuiltinTreeProviders`; downstream packages
+ * register their own at lower priority numbers to take
+ * over for specific repo roots.
+ */
+import { createGitWorktreeProvider } from "./providers/git-worktree.js";
+export const BUILTIN_TREE_PROVIDERS = [
+    createGitWorktreeProvider(),
+];

package/dist/internal/tree/providers/git-worktree.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Built-in git-worktree provider.
+ *
+ * Creates trees at `<repo>/.worktrees/<name>/` and ensures
+ * `.worktrees/` is gitignored in the host repo on first
+ * use. Prune refuses dirty working trees and unmerged
+ * branches unless `force: true`; a higher-level safety gate
+ * forwards the caller's resolution answer through the
+ * `force` flag.
+ *
+ * Default branch detection uses `git symbolic-ref` on
+ * `refs/remotes/origin/HEAD`, falling back to `main` then
+ * `master`. The `appliesTo` check is universal: this
+ * provider returns true for any directory inside a git
+ * working tree, so downstream packages register at lower
+ * priority to take over for specific repos.
+ */
+import type { TreeProvider } from "../../../tree/types.js";
+/** Build the provider. */
+export declare function createGitWorktreeProvider(priority?: number): TreeProvider;

package/dist/internal/tree/providers/git-worktree.js

@@ -0,0 +1,279 @@
+/**
+ * Built-in git-worktree provider.
+ *
+ * Creates trees at `<repo>/.worktrees/<name>/` and ensures
+ * `.worktrees/` is gitignored in the host repo on first
+ * use. Prune refuses dirty working trees and unmerged
+ * branches unless `force: true`; a higher-level safety gate
+ * forwards the caller's resolution answer through the
+ * `force` flag.
+ *
+ * Default branch detection uses `git symbolic-ref` on
+ * `refs/remotes/origin/HEAD`, falling back to `main` then
+ * `master`. The `appliesTo` check is universal: this
+ * provider returns true for any directory inside a git
+ * working tree, so downstream packages register at lower
+ * priority to take over for specific repos.
+ */
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const PROVIDER_ID = "git-worktree";
+const DEFAULT_PRIORITY = 100;
+const WORKTREES_DIR = ".worktrees";
+/**
+ * Slug pattern for tree names and base branches that
+ * flow into a path join and a git argv. Restrictive on
+ * purpose: alphanumeric plus dot, slash, underscore and
+ * dash, must not start with a dot or dash, and rejects
+ * `..` segments anywhere.
+ */
+const NAME_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/;
+function assertValidName(label, value) {
+    if (!value) {
+        throw new Error(`${label} cannot be empty.`);
+    }
+    if (!NAME_PATTERN.test(value)) {
+        throw new Error(`${label} must match ${NAME_PATTERN.source}; got ${JSON.stringify(value)}.`);
+    }
+    if (value.split("/").some((part) => part === "" || part === "..")) {
+        throw new Error(`${label} cannot contain empty or '..' path segments; got ${JSON.stringify(value)}.`);
+    }
+}
+/**
+ * Run a git command in a directory and return stdout
+ * trimmed. Throws on non-zero exit.
+ */
+async function git(cwd, ...args) {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.toString().trim();
+}
+/**
+ * Try a git command; return undefined on failure rather
+ * than throwing. Used for probes where "not a git repo"
+ * is a legitimate answer.
+ */
+async function tryGit(cwd, ...args) {
+    try {
+        return await git(cwd, ...args);
+    }
+    catch {
+        // Probe failed; caller treats this as "no answer".
+        return undefined;
+    }
+}
+/** Determine the repo's default branch. */
+async function detectDefaultBranch(repoRoot) {
+    const headRef = await tryGit(repoRoot, "symbolic-ref", "refs/remotes/origin/HEAD");
+    if (headRef?.startsWith("refs/remotes/origin/")) {
+        return headRef.slice("refs/remotes/origin/".length);
+    }
+    const main = await tryGit(repoRoot, "rev-parse", "--verify", "main");
+    if (main)
+        return "main";
+    const master = await tryGit(repoRoot, "rev-parse", "--verify", "master");
+    if (master)
+        return "master";
+    // As a last resort, return HEAD's current branch.
+    const current = await tryGit(repoRoot, "rev-parse", "--abbrev-ref", "HEAD");
+    return current ?? "main";
+}
+/**
+ * Make sure `.worktrees/` is gitignored at the repo root so
+ * the worktree directories don't show up as untracked
+ * files. Idempotent.
+ */
+function ensureGitignore(repoRoot) {
+    const path = join(repoRoot, ".gitignore");
+    const entry = `${WORKTREES_DIR}/`;
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const lines = existing.split("\n");
+    if (lines.some((line) => line.trim() === entry))
+        return;
+    const next = existing.length === 0 || existing.endsWith("\n")
+        ? `${existing}${entry}\n`
+        : `${existing}\n${entry}\n`;
+    writeFileSync(path, next, "utf8");
+}
+/**
+ * `git status --porcelain` produces one line per dirty
+ * file. Empty stdout means the tree is clean.
+ */
+async function isDirty(treePath) {
+    const status = await tryGit(treePath, "status", "--porcelain");
+    return Boolean(status && status.length > 0);
+}
+/**
+ * Return true when `branch` contains commits that the
+ * default branch does not.
+ *
+ * Tries `origin/<default>` first (the common shared-state
+ * comparison), then falls back to the local default
+ * branch when no origin remote is wired. If neither
+ * comparison succeeds the function returns true and lets
+ * the caller surface the lack of a target: silently
+ * returning false would let a force-less prune destroy
+ * unmerged work in a repo with no origin remote.
+ */
+async function hasUnmergedCommits(repoRoot, branch) {
+    const defaultBranch = await detectDefaultBranch(repoRoot);
+    if (defaultBranch === branch) {
+        return { unmerged: false, comparedAgainst: defaultBranch };
+    }
+    const originAhead = await tryGit(repoRoot, "rev-list", "--count", `origin/${defaultBranch}..${branch}`);
+    if (originAhead !== undefined) {
+        return {
+            unmerged: Number.parseInt(originAhead, 10) > 0,
+            comparedAgainst: `origin/${defaultBranch}`,
+        };
+    }
+    const localAhead = await tryGit(repoRoot, "rev-list", "--count", `${defaultBranch}..${branch}`);
+    if (localAhead !== undefined) {
+        return {
+            unmerged: Number.parseInt(localAhead, 10) > 0,
+            comparedAgainst: defaultBranch,
+        };
+    }
+    // No comparison target. Fail safe: claim unmerged so a
+    // non-force prune refuses with a clear message, and let
+    // the caller force when they know better.
+    return { unmerged: true, comparedAgainst: undefined };
+}
+/** Build the provider. */
+export function createGitWorktreeProvider(priority = DEFAULT_PRIORITY) {
+    return {
+        id: PROVIDER_ID,
+        priority,
+        appliesTo(repoRoot) {
+            // Cheap structural probe: `.git` exists either
+            // as a directory (normal clone) or a file
+            // (worktree). Symbolic-ref probes the real
+            // repository.
+            return existsSync(join(repoRoot, ".git"));
+        },
+        async create(input) {
+            assertValidName("Tree name", input.name);
+            if (input.baseBranch !== undefined) {
+                assertValidName("Base branch", input.baseBranch);
+            }
+            const repoRoot = resolve(input.repoRoot);
+            const treePath = join(repoRoot, WORKTREES_DIR, input.name);
+            if (existsSync(treePath)) {
+                throw new Error(`A tree already exists at ${treePath}. Pick a different name or prune the existing one first.`);
+            }
+            ensureGitignore(repoRoot);
+            const base = input.baseBranch ?? (await detectDefaultBranch(repoRoot));
+            // `--` separates positional args from refs so a base
+            // or branch name that happens to start with a dash
+            // (already refused by assertValidName) cannot be
+            // reparsed as a flag by older git versions.
+            await git(repoRoot, "worktree", "add", "-b", input.name, treePath, "--", base);
+            return {
+                path: treePath,
+                branch: input.name,
+                repoRoot,
+                providerId: PROVIDER_ID,
+            };
+        },
+        async prune(input) {
+            const treePath = resolve(input.path);
+            if (!existsSync(treePath)) {
+                // Tree directory is gone but git's admin entry
+                // may still be around. Walk up looking for the
+                // containing repo so we can run
+                // `git worktree prune` against it. When we
+                // can't find it, treat the prune as already
+                // done.
+                let ancestor = dirname(treePath);
+                while (ancestor !== dirname(ancestor)) {
+                    if (existsSync(join(ancestor, ".git"))) {
+                        await tryGit(ancestor, "worktree", "prune");
+                        return;
+                    }
+                    ancestor = dirname(ancestor);
+                }
+                return;
+            }
+            // `--show-toplevel` from inside a worktree returns
+            // the worktree path itself, not the main repo.
+            // `--git-common-dir` always points at the shared
+            // `.git`; the main repo is its parent.
+            const commonDir = await git(treePath, "rev-parse", "--git-common-dir");
+            const absoluteCommonDir = resolve(treePath, commonDir);
+            const repoRoot = dirname(absoluteCommonDir);
+            const branch = (await tryGit(treePath, "rev-parse", "--abbrev-ref", "HEAD")) ?? "";
+            if (!input.force) {
+                if (await isDirty(treePath)) {
+                    throw new Error(`Tree at ${treePath} has uncommitted changes. Commit, stash or force-prune.`);
+                }
+                if (branch) {
+                    const { unmerged, comparedAgainst } = await hasUnmergedCommits(repoRoot, branch);
+                    if (unmerged) {
+                        const target = comparedAgainst
+                            ? `against ${comparedAgainst}`
+                            : "and no default-branch comparison target exists (no origin remote, no local main/master)";
+                        throw new Error(`Branch ${branch} has commits not merged ${target}. Push and merge first, or force-prune.`);
+                    }
+                }
+            }
+            await git(repoRoot, "worktree", "remove", treePath, ...(input.force ? ["--force"] : []));
+            if (branch) {
+                // Delete the branch when it's fully merged
+                // or the caller forced. Failures here are
+                // non-fatal: the worktree itself is gone.
+                const deleteFlag = input.force ? "-D" : "-d";
+                await tryGit(repoRoot, "branch", deleteFlag, branch);
+            }
+        },
+        async list(repoRoot) {
+            const root = resolve(repoRoot);
+            const stdout = await tryGit(root, "worktree", "list", "--porcelain");
+            if (!stdout)
+                return [];
+            const handles = [];
+            let current = {};
+            for (const line of stdout.split("\n")) {
+                if (line.startsWith("worktree ")) {
+                    if (current.path) {
+                        handles.push({
+                            path: current.path,
+                            branch: current.branch,
+                            repoRoot: root,
+                            providerId: PROVIDER_ID,
+                        });
+                    }
+                    current = { path: line.slice("worktree ".length) };
+                }
+                else if (line.startsWith("branch ")) {
+                    const ref = line.slice("branch ".length);
+                    current.branch = ref.replace(/^refs\/heads\//, "");
+                }
+                else if (line === "") {
+                    if (current.path) {
+                        handles.push({
+                            path: current.path,
+                            branch: current.branch,
+                            repoRoot: root,
+                            providerId: PROVIDER_ID,
+                        });
+                        current = {};
+                    }
+                }
+            }
+            if (current.path) {
+                handles.push({
+                    path: current.path,
+                    branch: current.branch,
+                    repoRoot: root,
+                    providerId: PROVIDER_ID,
+                });
+            }
+            // The first entry is always the main worktree;
+            // drop it so callers see only the
+            // `.worktrees/<name>` siblings.
+            return handles.slice(1);
+        },
+    };
+}

package/dist/internal/tree/registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tree provider registry: process-global map from provider
+ * id to `TreeProvider`. Mirrors the refs and terminal
+ * libraries; uses the same shared `createGlobalSymbolRegistry`
+ * helper.
+ */
+import type { TreeProvider } from "../../tree/types.js";
+export declare const register: (provider: TreeProvider) => void;
+export declare const unregister: (id: string) => void;
+export declare const clear: () => void;
+export declare const get: (id: string) => TreeProvider | undefined;
+export declare const list: () => TreeProvider[];

package/dist/internal/tree/registry.js

@@ -0,0 +1,16 @@
+/**
+ * Tree provider registry: process-global map from provider
+ * id to `TreeProvider`. Mirrors the refs and terminal
+ * libraries; uses the same shared `createGlobalSymbolRegistry`
+ * helper.
+ */
+import { createGlobalSymbolRegistry } from "../registry/global-symbol-registry.js";
+const registry = createGlobalSymbolRegistry({
+    slot: "pi:agentic-harness:tree-providers",
+    getId: (p) => p.id,
+});
+export const register = (provider) => registry.register(provider);
+export const unregister = (id) => registry.unregister(id);
+export const clear = () => registry.clear();
+export const get = (id) => registry.get(id);
+export const list = () => registry.list();