@vzlentin/harness 0.0.0-stage → 0.2.0

package/dist/chrome.js

@@ -0,0 +1,74 @@
+import { homedir } from "node:os";
+import { calculateContextTokens } from "@earendil-works/pi-coding-agent";
+import { UsageDoc } from "@earendil-works/pi-durable";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { bold, color } from "./theme.js";
+import { docOf } from "./view-state.js";
+/** One line, cut to the width, with `hints` at the right end: the first hints go when they do not all fit. */
+export class Line {
+    text = "";
+    hints = [];
+    style = (text) => text;
+    render(width) {
+        for (let first = 0; first < this.hints.length; first++) {
+            const right = `${this.hints.slice(first).join(" · ")} `;
+            const gap = width - visibleWidth(this.text) - visibleWidth(right);
+            if (gap >= 2)
+                return [`${this.text}${" ".repeat(gap)}${this.style(right)}`];
+        }
+        return [truncateToWidth(this.text, width)];
+    }
+    invalidate() { }
+}
+/** `harness │ <title> │ <cwd> │ <state>`. */
+export function headerText(child, title) {
+    const state = child.state === "busy"
+        ? color("warning", "◉ busy")
+        : child.state === "idle"
+            ? color("success", "● idle")
+            : color("error", "⊗ error");
+    return ` ${[bold(color("accent", "harness")), title, color("muted", tildePath(child.cwd)), state].join(color("borderMuted", "  │  "))}`;
+}
+/**
+ * `<provider>/<model> · <thinking> │ <tokens> tok $<cost> │ <used>%/<window> ctx`. The context part shows when
+ * `contextWindow` is known and the child has answered once.
+ */
+export function footerText(child, view, contextWindow) {
+    const usage = totalUsage(docOf(view, UsageDoc));
+    const used = lastUsage(view.entries);
+    const context = contextWindow === undefined || contextWindow === 0 || used === undefined
+        ? []
+        : [`${((100 * used) / contextWindow).toFixed(1)}%/${compactCount(contextWindow)} ctx`];
+    return ` ${color("muted", [
+        `${child.provider}/${child.model} · ${child.thinking}`,
+        `${compactCount(usage.tokens)} tok $${usage.cost.toFixed(3)}`,
+        ...context,
+    ].join(" │ "))}`;
+}
+/** The tokens and the cost of every model request of the conversation. */
+function totalUsage(usage) {
+    let tokens = 0;
+    let cost = 0;
+    for (const model of Object.values(usage?.models ?? {})) {
+        tokens += model.totalTokens;
+        cost += model.cost.total;
+    }
+    return { tokens, cost };
+}
+function compactCount(count) {
+    return Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(count);
+}
+function tildePath(path) {
+    const home = homedir();
+    return home !== "" && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
+}
+/** The prompt and output tokens of the last answer, which fill the context window of the next request. */
+function lastUsage(entries) {
+    for (const entry of entries.toReversed()) {
+        const message = entry.model?.[0];
+        if (entry.kind !== "pi.assistant" || message?.role !== "assistant")
+            continue;
+        return calculateContextTokens(message.usage);
+    }
+    return undefined;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { addProject, checkProject, MAIN_PROJECT, projectDir, readProjects } from "./projects.js";
+import { AGENT_HANDLE, statePaths } from "./protocol.js";
+import { setupOnce } from "./setup.js";
+import { runTool, sendToHost } from "./tool.js";
+function fail(message) {
+    throw new Error(message);
+}
+function usage() {
+    fail(`Usage:
+  harness <project>
+  harness spawn [--name <name>] [--provider <provider>] [--model <model>] [--thinking <level>]
+    [--cwd <dir>] [--tools <names>] (--prompt <text> | --file <path>)...
+  harness status <handle>
+  harness rename <handle> <name>
+  harness send <handle> [--follow-up] <message>
+  harness wait <handle> [--timeout <seconds>]
+  harness stop <handle>
+  harness list
+  harness attach <handle>
+  harness create <name> --cwd <dir>
+  harness projects
+Any command but harness <project> takes --project <name> before it; without it, the project is HARNESS_PROJECT, then the cwd.`);
+}
+function valueAfter(args, index, option) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        fail(`${option} requires a value`);
+    return value;
+}
+function spawnArgs(args) {
+    const spawn = { action: "spawn" };
+    const prompts = [];
+    const files = [];
+    for (let i = 0; i < args.length; i += 2) {
+        const option = args[i];
+        switch (option) {
+            case "--name":
+                spawn.name = valueAfter(args, i, option);
+                break;
+            case "--provider":
+                spawn.provider = valueAfter(args, i, option);
+                break;
+            case "--model":
+                spawn.model = valueAfter(args, i, option);
+                break;
+            case "--thinking":
+                spawn.thinking = valueAfter(args, i, option);
+                break;
+            case "--cwd":
+                spawn.cwd = valueAfter(args, i, option);
+                break;
+            case "--tools":
+                spawn.tools = valueAfter(args, i, option).split(",");
+                break;
+            case "--prompt":
+                prompts.push(valueAfter(args, i, option));
+                break;
+            case "--file":
+                files.push(valueAfter(args, i, option));
+                break;
+            default:
+                fail(`Unknown spawn argument: ${option}`);
+        }
+    }
+    return { ...spawn, prompts, files };
+}
+function sendArgs(args) {
+    const [handle, ...rest] = args;
+    if (!handle)
+        usage();
+    let followUp = false;
+    const messageParts = [];
+    for (const arg of rest) {
+        if (arg === "--follow-up")
+            followUp = true;
+        else if (arg.startsWith("--"))
+            fail(`Unknown send argument: ${arg}`);
+        else
+            messageParts.push(arg);
+    }
+    return { action: "send", handle, message: messageParts.join(" "), followUp };
+}
+function waitArgs(args) {
+    const [handle, ...rest] = args;
+    if (!handle)
+        usage();
+    if (rest.length === 0)
+        return { action: "wait", handle };
+    if (rest.length !== 2 || rest[0] !== "--timeout")
+        usage();
+    const timeout = Number(rest[1]);
+    if (!Number.isInteger(timeout) || timeout <= 0)
+        fail("--timeout must be a positive integer");
+    return { action: "wait", handle, timeout };
+}
+/** The tool arguments of a CLI command. */
+function toolArgs(command, args) {
+    const [first, second] = args;
+    switch (command) {
+        case "spawn":
+            return spawnArgs(args);
+        case "send":
+            return sendArgs(args);
+        case "wait":
+            return waitArgs(args);
+        case "status":
+        case "stop":
+            if (args.length !== 1 || first === undefined)
+                usage();
+            return { action: command, handle: first };
+        case "rename":
+            if (args.length !== 2 || first === undefined || second === undefined)
+                usage();
+            return { action: command, handle: first, name: second };
+        case "list":
+            if (args.length !== 0)
+                usage();
+            return { action: command };
+        default:
+            usage();
+    }
+}
+/** The commands, which a project cannot have as its name. */
+const COMMANDS = new Set([
+    "spawn",
+    "status",
+    "rename",
+    "send",
+    "wait",
+    "stop",
+    "list",
+    "attach",
+    "host",
+    "create",
+    "projects",
+]);
+/** Adds the project `name` with the real path of `dir` to `projects.json`. */
+function createCommand(args) {
+    const [name, option, dir] = args;
+    if (args.length !== 3 || name === undefined || option !== "--cwd" || dir === undefined)
+        usage();
+    if (COMMANDS.has(name))
+        fail(`A project cannot have the name ${name}`);
+    process.stdout.write(`Created ${name} (${addProject(name, dir)})\n`);
+}
+function projectsCommand(args) {
+    if (args.length !== 0)
+        usage();
+    for (const [name, dir] of Object.entries(readProjects()))
+        process.stdout.write(`${name}  ${dir}\n`);
+    process.stdout.write(`${MAIN_PROJECT}\n`);
+}
+/**
+ * Runs the host of `project` in this process with Pi's models. It exits at once when another host runs. The project
+ * comes only from `--project`, not from the env: a host can start from a child's shell of another project.
+ */
+async function hostCommand(args, project) {
+    if (args.length !== 0)
+        usage();
+    const { createAgentSessionServices } = await import("@earendil-works/pi-coding-agent");
+    const { runHost } = await import("./host.js");
+    const { modelRuntime } = await createAgentSessionServices({ cwd: process.cwd() });
+    const host = await runHost({
+        stateDir: statePaths(project).dir,
+        project,
+        cwd: projectDir(project),
+        models: modelRuntime,
+    });
+    if (host === undefined) {
+        process.stderr.write(`Another harness host runs (pid ${process.pid} exits)\n`);
+        process.exit(0);
+    }
+    for (const signal of ["SIGINT", "SIGTERM"])
+        process.once(signal, () => void host.close());
+    await host.closed;
+    process.exit(0);
+}
+/** Opens the viewer of a child in this terminal. */
+async function attachCommand(args) {
+    const [handle] = args;
+    if (args.length !== 1 || handle === undefined)
+        usage();
+    await openViewer(handle);
+}
+/** Opens the viewer of the agent of the project `name`, which is `main` or a project, in this terminal. */
+async function agentCommand(name, project) {
+    if (project !== undefined)
+        fail(`harness ${name} takes no --project`);
+    // The viewer's connection resolves the project from the env.
+    process.env.HARNESS_PROJECT = name;
+    await openViewer(AGENT_HANDLE);
+}
+async function openViewer(handle) {
+    const { ProcessTerminal } = await import("@earendil-works/pi-tui");
+    const { attach } = await import("./viewer.js");
+    process.exitCode = await attach(handle, { terminal: new ProcessTerminal(), env: process.env });
+}
+/**
+ * Runs a command as a call of the `subagent` tool. The caller is `PI_SESSION_ID`, or `cli` outside Pi, and the defaults
+ * of a spawn come from `PI_PROVIDER`, `PI_MODEL` and `PI_REASONING_LEVEL`.
+ */
+async function main() {
+    const all = process.argv.slice(2);
+    // Only before the command, so a message or a prompt can contain the word.
+    let project;
+    if (all[0] === "--project") {
+        project = valueAfter(all, 0, "--project");
+        all.splice(0, 2);
+    }
+    const [command, ...args] = all;
+    // npm 12 runs no install script by default, so an installed CLI finishes the setup. A checkout runs `cli.ts`, and
+    // the host starts from a command that already did it.
+    if (import.meta.url.endsWith(".js") && command !== "host")
+        setupOnce(fileURLToPath(new URL("..", import.meta.url)));
+    if (command === "create")
+        return createCommand(args);
+    if (command === "projects")
+        return projectsCommand(args);
+    if (command === "host")
+        return hostCommand(args, checkProject(project ?? MAIN_PROJECT));
+    // A project alone opens its agent. Any other word goes to the usage.
+    if (command !== undefined &&
+        !COMMANDS.has(command) &&
+        args.length === 0 &&
+        (command === MAIN_PROJECT || Object.hasOwn(readProjects(), command))) {
+        return agentCommand(command, project);
+    }
+    // Every connection resolves the project from the env, so --project goes there.
+    if (project !== undefined)
+        process.env.HARNESS_PROJECT = checkProject(project);
+    if (command === "attach")
+        return attachCommand(args);
+    const { text } = await runTool(toolArgs(command, args), {
+        caller: process.env.PI_SESSION_ID || "cli",
+        callKey: randomUUID(),
+        provider: process.env.PI_PROVIDER,
+        model: process.env.PI_MODEL,
+        thinking: process.env.PI_REASONING_LEVEL || "medium",
+        cwd: process.cwd(),
+        send: sendToHost,
+        signal: undefined,
+    });
+    process.stdout.write(text);
+}
+main().catch((cause) => {
+    process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
+    process.exitCode = 1;
+});

package/dist/client.d.ts

@@ -0,0 +1,49 @@
+import { type Socket } from "node:net";
+import { type Replies, type Request, type WatchLine } from "./protocol.ts";
+/**
+ * A connection to the host. Requests are answered in order, one reply line for each request line. After `watch`, the
+ * event lines of the watch come between the replies.
+ */
+export declare class Client {
+    #private;
+    /** The process ID of the host, from its `hello` reply. */
+    pid: number;
+    /** The project of the host. `connect` sets it. */
+    project: string;
+    constructor(socket: Socket);
+    request<T extends Request["type"]>(request: Extract<Request, {
+        type: T;
+    }>): Promise<Replies[T]>;
+    /**
+     * Sends the `watch` request of `handle`. Its `lines` are the events of the watch, and end when the connection closes.
+     * Other requests can follow on this client. Call it once.
+     */
+    watch(handle: string): Promise<Replies["watch"] & {
+        lines: AsyncIterable<WatchLine>;
+    }>;
+    close(): void;
+    /** Rejects the pending requests with `cause` and closes the connection. The host then stops them. */
+    abort(cause: unknown): void;
+}
+/**
+ * A connection to the host of the project of `HARNESS_PROJECT` or the cwd (see `resolveProject`), after its `hello`.
+ * When no host listens and `start` is true, it starts one, detached, with its output in `host.log`, and tries to
+ * connect for 10 s, or until `signal` aborts. When no host listens and `start` is false, it is undefined.
+ */
+export declare function connect(options: ConnectOptions): Promise<Client | undefined>;
+type ConnectOptions = {
+    readonly start: boolean;
+    readonly signal?: AbortSignal | undefined;
+};
+type OneShot<T extends Request["type"]> = Extract<Request, {
+    type: T;
+}>;
+/**
+ * Connects as `connect` does, sends `request`, and closes the connection. It is undefined when no host listens and
+ * `start` is false. When `signal` aborts, it rejects with the abort reason, and the host stops the request.
+ */
+export declare function request<T extends Request["type"]>(request: OneShot<T>, options: ConnectOptions & {
+    readonly start: true;
+}): Promise<Replies[T]>;
+export declare function request<T extends Request["type"]>(request: OneShot<T>, options: ConnectOptions): Promise<Replies[T] | undefined>;
+export {};

package/dist/client.js

@@ -0,0 +1,176 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync, openSync } from "node:fs";
+import { createConnection } from "node:net";
+import { Readable } from "node:stream";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { MAIN_PROJECT, resolveProject } from "./projects.js";
+import { cliPath, onLines, PROTOCOL_VERSION, statePaths, } from "./protocol.js";
+const START_TIMEOUT_MS = 10_000;
+/** A line from the host: a reply, or an event of the watch. The value of a reply and the event are not checked here. */
+const HostLine = Type.Union([
+    Type.Object({ ok: Type.Literal(true), value: Type.Optional(Type.Unknown()) }),
+    Type.Object({ ok: Type.Literal(false), error: Type.String() }),
+    Type.Object({ event: Type.Unknown() }),
+]);
+/**
+ * A connection to the host. Requests are answered in order, one reply line for each request line. After `watch`, the
+ * event lines of the watch come between the replies.
+ */
+export class Client {
+    #socket;
+    #pending = [];
+    #ended = false;
+    /** The events of the watch. Only `watch` sets it; otherwise an event is dropped. */
+    #lines;
+    /** The process ID of the host, from its `hello` reply. */
+    pid = 0;
+    /** The project of the host. `connect` sets it. */
+    project = MAIN_PROJECT;
+    constructor(socket) {
+        this.#socket = socket;
+        onLines(socket, (line) => {
+            const parsed = JSON.parse(line);
+            if (!Value.Check(HostLine, parsed)) {
+                this.#pending.shift()?.reject(new Error(`The harness host sent an invalid reply: ${line}`));
+                return;
+            }
+            if ("event" in parsed) {
+                this.#lines?.push(parsed.event);
+                return;
+            }
+            const waiter = this.#pending.shift();
+            if (waiter === undefined)
+                return;
+            if (parsed.ok)
+                waiter.resolve(parsed.value);
+            else
+                waiter.reject(new Error(parsed.error));
+        });
+        socket.on("error", () => this.#end());
+        socket.on("close", () => this.#end());
+    }
+    request(request) {
+        if (this.#ended)
+            return Promise.reject(new Error("The harness host closed the connection"));
+        const reply = Promise.withResolvers();
+        this.#pending.push(reply);
+        this.#socket.write(`${JSON.stringify(request)}\n`);
+        // SAFETY: the host answers each request line in order with the value of `Replies` for its type, and `connect`
+        // refuses a host of another protocol version.
+        return reply.promise;
+    }
+    /**
+     * Sends the `watch` request of `handle`. Its `lines` are the events of the watch, and end when the connection closes.
+     * Other requests can follow on this client. Call it once.
+     */
+    async watch(handle) {
+        const lines = new Readable({ objectMode: true, read() { } });
+        this.#lines = lines;
+        const reply = await this.request({ type: "watch", handle });
+        return { ...reply, lines };
+    }
+    close() {
+        this.#socket.end();
+    }
+    /** Rejects the pending requests with `cause` and closes the connection. The host then stops them. */
+    abort(cause) {
+        this.#end(cause);
+        this.#socket.destroy();
+    }
+    #end(cause = new Error("The harness host closed the connection")) {
+        if (!this.#ended)
+            this.#lines?.push(null);
+        this.#ended = true;
+        for (const waiter of this.#pending.splice(0))
+            waiter.reject(cause);
+    }
+}
+/**
+ * A connection to the host of the project of `HARNESS_PROJECT` or the cwd (see `resolveProject`), after its `hello`.
+ * When no host listens and `start` is true, it starts one, detached, with its output in `host.log`, and tries to
+ * connect for 10 s, or until `signal` aborts. When no host listens and `start` is false, it is undefined.
+ */
+export async function connect(options) {
+    const project = resolveProject(process.env, process.cwd());
+    const paths = statePaths(project);
+    let socket = await tryConnect(paths.socket);
+    if (socket === undefined) {
+        if (!options.start)
+            return undefined;
+        startHost(project, paths.dir, paths.log);
+        const deadline = Date.now() + START_TIMEOUT_MS;
+        while (socket === undefined) {
+            options.signal?.throwIfAborted();
+            if (Date.now() > deadline)
+                throw new Error(`Could not start the harness host; see ${paths.log}`);
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 100));
+            socket = await tryConnect(paths.socket);
+        }
+    }
+    const client = new Client(socket);
+    try {
+        const hello = await client.request({ type: "hello", version: PROTOCOL_VERSION });
+        // A stopped host restarts from the installed code, which is the newer side here, so only the client can catch up.
+        if (hello.version > PROTOCOL_VERSION) {
+            throw new Error(`This client uses harness protocol ${PROTOCOL_VERSION} and the host (pid ${hello.pid}) uses ${hello.version}. Reload Pi with /reload, or use the harness CLI of the host's install`);
+        }
+        if (hello.version !== PROTOCOL_VERSION) {
+            throw new Error(`The harness host (pid ${hello.pid}) uses protocol ${hello.version}, not ${PROTOCOL_VERSION}. The host is older: stop it with kill ${hello.pid} and run the command again`);
+        }
+        client.pid = hello.pid;
+        client.project = project;
+        return client;
+    }
+    catch (error) {
+        client.close();
+        throw error;
+    }
+}
+export async function request(request, options) {
+    const { signal } = options;
+    const client = await connect(options);
+    if (client === undefined)
+        return undefined;
+    const abort = () => client.abort(signal?.reason);
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+        signal?.throwIfAborted();
+        return await client.request(request);
+    }
+    finally {
+        signal?.removeEventListener("abort", abort);
+        client.close();
+    }
+}
+/** The connected socket, or undefined when nothing listens at `path`. */
+function tryConnect(path) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(path);
+        socket.once("connect", () => {
+            socket.removeAllListeners("error");
+            resolve(socket);
+        });
+        socket.once("error", (error) => {
+            if (error.code === "ENOENT" || error.code === "ECONNREFUSED")
+                resolve(undefined);
+            else
+                reject(error);
+        });
+    });
+}
+function startHost(project, dir, log) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const output = openSync(log, "a", 0o600);
+    try {
+        const cli = cliPath();
+        spawn(process.execPath, [cli, "--project", project, "host"], {
+            cwd: dir,
+            detached: true,
+            stdio: ["ignore", output, output],
+        }).unref();
+    }
+    finally {
+        closeSync(output);
+    }
+}

package/dist/context.d.ts

@@ -0,0 +1,13 @@
+import { type ToolRegistration } from "@earendil-works/pi-durable";
+/** The tools and sections that children get; a conversation selects it by default. */
+export declare const ChildContext: import("@earendil-works/pi-durable").Extension<ToolRegistration | ToolRegistration<import("typebox").TObject<{
+    path: import("typebox").TString;
+    offset: import("typebox").TOptional<import("typebox").TNumber>;
+    limit: import("typebox").TOptional<import("typebox").TNumber>;
+}>, import("@earendil-works/pi-durable/tools").ReadToolDetails> | ToolRegistration<import("typebox").TObject<{
+    path: import("typebox").TString;
+    edits: import("typebox").TArray<import("typebox").TObject<{
+        oldText: import("typebox").TString;
+        newText: import("typebox").TString;
+    }>>;
+}>, import("@earendil-works/pi-durable/tools").EditToolDetails>>;

package/dist/context.js

@@ -0,0 +1,115 @@
+/**
+ * What a child sees of its working directory, as a Pi session there sees it: the coding tools, and the system prompt
+ * sections with the project instructions, the skills and the working directory.
+ */
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createFindTool, createGrepTool, createLsTool, DefaultPackageManager, formatSkillsForPrompt, getAgentDir, loadProjectContextFiles, loadSkills, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { defineExtension, defineTool, section, } from "@earendil-works/pi-durable";
+import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@earendil-works/pi-durable/tools";
+import { savedTrust } from "./trust.js";
+/** A Pi coding agent tool as a durable tool that runs in the calling conversation's directory. */
+function piTool(create) {
+    const { name, description, parameters } = create(".");
+    return defineTool({
+        name,
+        description,
+        parameters,
+        replay: "safe",
+        execute: async (args, api, context) => {
+            const { cwd } = await api.agent(context);
+            if (cwd === undefined)
+                throw new Error(`${name} needs a working directory`);
+            const result = await create(cwd).execute(api.callId, args, context.abortSignal);
+            return { output: result.content };
+        },
+    });
+}
+const resources = new Map();
+/**
+ * The project instructions and skills of `cwd`, as Pi loads them at startup. Project skills load only for a project
+ * that Pi trusts now. They are loaded once per directory and trust. Missing packages are skipped, not installed. A
+ * load that fails gives no resources, with a warning, as Pi skips a resource it cannot load, and the next request
+ * tries again.
+ */
+async function resourcesOf(cwd) {
+    try {
+        const trusted = savedTrust(cwd);
+        const key = `${trusted}:${cwd}`;
+        let found = resources.get(key);
+        if (found === undefined) {
+            found = loadResources(cwd, trusted);
+            resources.set(key, found);
+            found.catch(() => resources.delete(key));
+        }
+        return await found;
+    }
+    catch (error) {
+        process.stderr.write(`warning: ${cwd}: ${error instanceof Error ? error.message : String(error)}; no project instructions or skills\n`);
+        return { context: [], skills: [] };
+    }
+}
+async function loadResources(cwd, trusted) {
+    const agentDir = getAgentDir();
+    const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: trusted });
+    const resolved = await new DefaultPackageManager({ cwd, agentDir, settingsManager }).resolve(async () => "skip");
+    const skillPaths = resolved.skills.filter(({ enabled }) => enabled).map(skillPath);
+    return {
+        context: loadProjectContextFiles({ cwd, agentDir }),
+        skills: loadSkills({ cwd, agentDir, skillPaths, includeDefaults: false }).skills,
+    };
+}
+/** The path that Pi loads a resolved skill from: the `SKILL.md` of a discovered or packaged skill directory. */
+function skillPath(resource) {
+    if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package")
+        return resource.path;
+    const file = join(resource.path, "SKILL.md");
+    try {
+        return statSync(resource.path).isDirectory() && existsSync(file) ? file : resource.path;
+    }
+    catch {
+        return resource.path;
+    }
+}
+const cwdOf = (input) => input.env?.cwd ?? input.agent.cwd;
+/** The resources of the conversation's directory. */
+async function inputResources(input) {
+    const cwd = cwdOf(input);
+    return cwd === undefined ? undefined : resourcesOf(cwd);
+}
+/** The tools and sections that children get; a conversation selects it by default. */
+export const ChildContext = defineExtension({
+    name: "pi-subagent-context",
+    tools: [
+        createReadTool(),
+        piTool(createGrepTool),
+        piTool(createFindTool),
+        piTool(createLsTool),
+        createWriteTool(),
+        createEditTool(),
+        createBashTool(),
+    ],
+    sections: [
+        section("project_context", async (input) => {
+            const files = (await inputResources(input))?.context ?? [];
+            if (files.length === 0)
+                return undefined;
+            return [
+                "Project-specific instructions and guidelines:",
+                ...files.map(({ path, content }) => `<project_instructions path="${path}">\n${content}\n</project_instructions>`),
+            ].join("\n\n");
+        }),
+        section("skills", async (input) => {
+            // As in Pi, skills need a tool that reads their files, and the hint names the first one offered.
+            const offered = input.agent.tools.map(({ name }) => name);
+            const callable = input.agent.callable.map(({ name }) => name);
+            const reader = ["read", "bash"].find((name) => offered.includes(name)) ??
+                (callable.includes("read") || callable.includes("bash") ? "indirect" : undefined);
+            if (reader === undefined)
+                return undefined;
+            const skills = (await inputResources(input))?.skills ?? [];
+            return formatSkillsForPrompt(skills, reader).trim() || undefined;
+        }),
+        section("cwd", (input) => cwdOf(input)?.replace(/\\/g, "/")),
+    ],
+});