@marcoscale98/piewf-herdr 5.14.1-fork.1

package/README.md

@@ -0,0 +1,70 @@
+# `@marcoscale98/piewf-herdr`
+
+Connect workflow agents to Herdr panes. The extension adds contextual `/workflow` actions for live handoff and completed-session inspection, plus an optional mode that runs every workflow agent in Herdr.
+
+[Full Herdr documentation](https://vekexasia.github.io/pi-extensible-workflows/herdr.html) | [Main package](https://github.com/vekexasia/pi-extensible-workflows#readme) | [Workflow operations](https://vekexasia.github.io/pi-extensible-workflows/developers.html#operations)
+
+## Requirements and installation
+
+- Node.js 22.19 or newer.
+- `@marcoscale98/pi-extensible-workflows` loaded in Pi.
+- Pi running inside a Herdr-managed pane.
+- Trusted package code and project context.
+
+```sh
+pi install npm:@marcoscale98/pi-extensible-workflows@fork
+pi install npm:@marcoscale98/piewf-herdr@fork
+```
+
+The extension activates only when Herdr is available. It registers workflow attempt actions and a transport setup hook, not model-facing tools. Set `PI_CODING_AGENT_DIR` if the Pi agent directory is not `~/.pi/agent`.
+
+## Available `/workflow` actions
+
+| Action | Available when | Behavior |
+| --- | --- | --- |
+| Open live session in Herdr pane | The latest attempt has a transferable live session and fully inspectable mode is off. | Suspends local ownership at a turn boundary, opens the same session in Herdr, and returns ownership after handback. |
+| Open session in Herdr pane | The latest attempt is completed, failed, or cancelled and has a persisted session reference. | Opens the existing session in a separate Herdr pane for inspection without taking workflow ownership. |
+
+Open `/workflow`, select a run, then select the agent attempt to see the applicable action.
+
+## Fully inspectable mode
+
+Set the global workflow settings file, normally `~/.pi/agent/pi-extensible-workflows/settings.json`:
+
+```json
+{
+  "extensionSettings": {
+    "herdr": {
+      "enableFullyInspectableMode": true
+    }
+  }
+}
+```
+
+`extensionSettings.herdr` is the only valid location for Herdr configuration. The obsolete `extensions.herdr` object is rejected with `INVALID_SETTINGS`; migrate it before launching.
+
+The effective value uses the global map unless a trusted project declares `extensionSettings`, in which case the project's complete map replaces it, including `{}`. Role settings are then applied by top-level-key replacement; nested objects and arrays are not merged. Untrusted project settings are ignored. When enabled, every workflow agent launches in a dedicated labeled Herdr workspace and the manual live-session action is hidden. Completed-session inspection remains available.
+
+## Live handoff and ownership
+
+Live handoff pauses the local SDK at a turn boundary while the Herdr pane owns the task. A generated bridge reports Pi's `agent_settled` event directly to the transport, independently of user extension filters and Herdr screen detection. This returns ownership to the local SDK and closes the owned pane; accepting `workflow_result` alone does not end the execution. Pane exit, `/quit`, and cancellation remain fallback paths.
+
+The extension preserves the originating Pi executable and entrypoint, model, tools, role/resource policy, context selection, prompt configuration, custom result tools, and transferable inline extensions. Temporary bridge files use private permissions; files and sockets are cleaned after the pane closes.
+
+## Interruption behavior and limitations
+
+- Herdr's Pi screen detection cannot distinguish an aborted turn from a completed turn.
+- In Pi's default keybindings, use double-`Escape` to abort a turn. A single `Ctrl-C` clears the editor and double-`Ctrl-C` exits Pi, so `Ctrl-C` is not a handback signal.
+- Lifecycle reports from this extension are advisory when Herdr's built-in Pi integration has authority.
+- A live handoff requires a transferable session file and an available originating Pi runtime.
+- Inline extension factories are materialized as temporary explicit extensions in the Herdr pane.
+
+## Development
+
+From the repository root:
+
+```sh
+npm run build --workspace=packages/extensions/herdr
+npm test --workspace=packages/extensions/herdr
+npm run lint --workspace=packages/extensions/herdr
+```

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AgentAttemptAction, AgentIdentity, AgentSetupHook, HerdrCommandRunner, HerdrWorkspacePane, HerdrWorkspacePaneRequest, WorkflowExtension, WorkflowRunContext } from "@marcoscale98/pi-extensible-workflows";
+type WorkspaceManager = {
+    open(run: Readonly<WorkflowRunContext>, request: HerdrWorkspacePaneRequest): Promise<HerdrWorkspacePane>;
+    close(runId: string): Promise<void>;
+    closeAll(): Promise<void>;
+};
+type HerdrBreadcrumbIdentity = Omit<AgentIdentity, "structuralPath"> & {
+    structuralPath?: readonly string[];
+};
+export interface HerdrExtensionOptions {
+    env?: NodeJS.ProcessEnv;
+    runner?: HerdrCommandRunner;
+    workspaces?: WorkspaceManager;
+    agentDir?: string;
+}
+type HerdrExtensionOverrides = Pick<HerdrExtensionOptions, "env" | "runner" | "workspaces">;
+export interface HerdrExtension extends WorkflowExtension {
+    agentAttemptActions: {
+        openSession: AgentAttemptAction;
+        openLiveSession: AgentAttemptAction;
+    };
+    agentSetupHooks: {
+        fullyInspectable: AgentSetupHook;
+    };
+}
+export declare function isFullyInspectableMode(agentDirectory?: string): boolean;
+export declare function breadcrumbLabel(identity: Readonly<HerdrBreadcrumbIdentity>, attempt?: number): string;
+export declare function createHerdrExtension(options?: HerdrExtensionOptions): HerdrExtension;
+export declare function registerHerdrExtension(options?: HerdrExtensionOptions): boolean;
+export default function extension(pi: ExtensionAPI, overrides?: HerdrExtensionOverrides): void;
+export {};

package/dist/index.js

@@ -0,0 +1,851 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdtempSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { createServer } from "node:net";
+import { join } from "node:path";
+import { createExtensionRuntime, ExtensionRunner, ModelRegistry, ModelRuntime, SessionManager } from "@earendil-works/pi-coding-agent";
+import { WORKFLOW_BLOCKED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, createHerdrAgentReporter, createToolTimingExtension, errorText, herdrAvailable, herdrCommandRunner, loadSettings, openHerdrLivePane, waitForHerdrPane, registerWorkflowExtension, workflowSettingsPath, } from "@marcoscale98/pi-extensible-workflows";
+function agentDir() { return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"); }
+function settings(agentDirectory = agentDir()) {
+    try {
+        return loadSettings(workflowSettingsPath(agentDirectory));
+    }
+    catch {
+        return {};
+    }
+}
+function herdrConfig(agentDirectory = agentDir()) {
+    const workflowSettings = settings(agentDirectory);
+    return workflowSettings.extensionSettings?.herdr ?? {};
+}
+export function isFullyInspectableMode(agentDirectory = agentDir()) { return herdrConfig(agentDirectory).enableFullyInspectableMode === true; }
+export function breadcrumbLabel(identity, attempt = 1) {
+    const parts = [
+        ...(identity.structuralPath ?? []),
+        ...(identity.parentBreadcrumb ? [identity.parentBreadcrumb] : []),
+        ...(identity.worktreeOwner ? [`worktree:${identity.worktreeOwner}`] : []),
+        identity.callSite,
+    ].filter((part) => typeof part === "string" && part.trim());
+    return `${parts.join(" > ")} #${String(attempt)}`;
+}
+function quote(value) { return `'${value.replace(/'/g, `'\\''`)}'`; }
+function messageContent(message) { return message !== null && typeof message === "object" && !Array.isArray(message) ? message.content : undefined; }
+function hasToolCall(message) { const content = messageContent(message); return Array.isArray(content) && content.some((part) => part !== null && typeof part === "object" && part.type === "toolCall"); }
+function hasNamedToolCall(message, name) { const content = messageContent(message); return Array.isArray(content) && content.some((part) => part !== null && typeof part === "object" && part.type === "toolCall" && part.name === name); }
+function needsContinuation(message) { return !message || message.stopReason === "aborted" || hasToolCall(message); }
+function usableCwd(cwd) {
+    if (typeof cwd !== "string" || !cwd.trim())
+        return false;
+    try {
+        return statSync(cwd).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function completedSessionCwd(context) { return [context.attempt?.setup?.cwd, context.run?.cwd].find(usableCwd); }
+function formatContextFiles(files) { return files.length ? `<project_context>\n\nProject-specific instructions and guidelines:\n\n${files.map(({ path, content }) => `<project_instructions path="${path}">\n${content}\n</project_instructions>`).join("\n\n")}\n</project_context>\n` : ""; }
+function createCommandFiles(prepared, prompt, directPrompt, contextFiles) {
+    const paths = [];
+    const create = (kind, value) => {
+        const path = join(tmpdir(), `pi-herdr-${kind}-${String(process.pid)}-${randomBytes(6).toString("hex")}.txt`);
+        writeFileSync(path, value, { encoding: "utf8", mode: 0o600 });
+        paths.push(path);
+        return path;
+    };
+    const files = {
+        systemPrompt: prepared.systemPrompt === undefined ? undefined : create("system-prompt", prepared.systemPrompt),
+        appendPrompt: prepared.systemPromptAppend ? create("append-prompt", prepared.systemPromptAppend) : undefined,
+        contextPrompt: contextFiles && formatContextFiles(contextFiles) ? create("context-prompt", formatContextFiles(contextFiles)) : undefined,
+        prompt: prompt === undefined || directPrompt ? undefined : create("prompt", prompt),
+        settingsFile: create("settings", JSON.stringify(prepared.settings ?? {})),
+    };
+    return { ...files, command(value) { return `sh ${quote(create("command", `${value}\n`))}`; }, async close() { for (const path of paths) {
+            try {
+                unlinkSync(path);
+            }
+            catch { /* Cleanup is best effort after the child exits. */ }
+        } } };
+}
+function resourcePaths(session) {
+    const value = session.getHerdrResourcePaths?.();
+    if (!value || typeof value !== "object")
+        return { extensions: [], skills: [] };
+    return {
+        extensions: Array.isArray(value.extensions) ? value.extensions.filter((path) => typeof path === "string") : [],
+        skills: Array.isArray(value.skills) ? value.skills.filter((path) => typeof path === "string") : [],
+    };
+}
+function sessionPath(reference) {
+    const locator = reference?.locator;
+    return locator && typeof locator === "object" && !Array.isArray(locator) && typeof locator.sessionFile === "string" ? locator.sessionFile : undefined;
+}
+function materializeSessionForHandoff(session, prepared) {
+    const path = sessionPath(session.reference);
+    if (!path || existsSync(path))
+        return;
+    const manager = SessionManager.inMemory(prepared.cwd, session.reference.sessionId ? { id: session.reference.sessionId } : undefined);
+    manager.appendSessionInfo(prepared.sessionLabel);
+    const header = manager.getHeader();
+    if (!header)
+        throw new Error("Herdr cannot materialize a workflow session without a session header.");
+    const content = [header, ...manager.getEntries()].map((entry) => JSON.stringify(entry)).join("\n") + "\n";
+    try {
+        writeFileSync(path, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    }
+    catch (error) {
+        if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST")
+            throw error;
+    }
+}
+async function createBridgeContext(session, prepared) {
+    const reference = session.reference;
+    const path = sessionPath(reference);
+    const sessionManager = path && existsSync(path) ? SessionManager.open(path, undefined, prepared.cwd) : SessionManager.inMemory(prepared.cwd, { id: reference.sessionId });
+    const shared = session.getHerdrModelContext?.();
+    let fallbackRegistry;
+    if (shared?.modelRegistry === undefined) {
+        const directory = prepared.agentDir ?? agentDir();
+        const modelRuntime = await ModelRuntime.create({ authPath: join(directory, "auth.json"), modelsPath: join(directory, "models.json") });
+        fallbackRegistry = new ModelRegistry(modelRuntime);
+    }
+    const modelRegistry = shared?.modelRegistry ?? fallbackRegistry;
+    if (modelRegistry === undefined)
+        throw new Error("Herdr cannot bridge tools without the local model registry.");
+    const model = shared?.model ?? modelRegistry.find(prepared.model.provider, prepared.model.model);
+    const runner = new ExtensionRunner([], createExtensionRuntime(), prepared.cwd, sessionManager, modelRegistry);
+    runner.setUIContext(undefined, "tui");
+    const baseContext = runner.createContext();
+    return (signal, abort) => new Proxy(baseContext, {
+        get(target, property, receiver) {
+            const current = session.getHerdrModelContext?.();
+            if (property === "model")
+                return current?.model ?? model;
+            if (property === "modelRegistry")
+                return current?.modelRegistry ?? modelRegistry;
+            if (property === "thinkingLevel")
+                return prepared.model.thinking;
+            if (property === "isIdle")
+                return () => false;
+            if (property === "isProjectTrusted")
+                return () => prepared.resourcePolicy?.projectTrusted ?? true;
+            if (property === "signal")
+                return signal;
+            if (property === "abort")
+                return abort;
+            const reflected = Reflect.get(target, property, receiver);
+            return reflected;
+        },
+    });
+}
+function inspectSessionCommand(reference) {
+    const source = sessionPath(reference) ?? reference.sessionId;
+    return `pi --session ${quote(source)} --tools ${quote("read,grep,find,ls")}`;
+}
+function inlineFactorySource(extension) {
+    const factory = typeof extension === "function" ? extension : typeof extension === "object" && typeof extension.factory === "function" ? extension.factory : undefined;
+    if (!factory)
+        throw new Error("Herdr live sessions cannot transfer an invalid inline extension factory.");
+    const source = Function.prototype.toString.call(factory);
+    if (source.includes("[native code]"))
+        throw new Error("Herdr live sessions cannot transfer a native inline extension factory.");
+    return source;
+}
+function createInlineExtensionBridge(prepared) {
+    const timingFactory = createToolTimingExtension();
+    const factories = prepared.extensionFactories?.includes(timingFactory) ? [...(prepared.extensionFactories ?? [])] : [...(prepared.extensionFactories ?? []), timingFactory];
+    const extensionPath = join(tmpdir(), `pi-herdr-extensions-${String(process.pid)}-${randomBytes(6).toString("hex")}.mjs`);
+    const source = `const factories = [${factories.map(inlineFactorySource).join(",")}];\nexport default async function(pi) { for (const factory of factories) await factory(pi); }\n`;
+    writeFileSync(extensionPath, source, { encoding: "utf8", mode: 0o600 });
+    return { extensionPath, async close() { try {
+            unlinkSync(extensionPath);
+        }
+        catch { /* Cleanup is best effort after the child exits. */ } } };
+}
+function isToolBridgeRequest(value) {
+    return value !== null && typeof value === "object" && typeof value.toolCallId === "string" && typeof value.name === "string";
+}
+function isLifecycleBridgeRequest(value) {
+    return value !== null && typeof value === "object" && value.type === "agent_settled";
+}
+function toolBridgeRequest(value) {
+    if (isToolBridgeRequest(value))
+        return value;
+    const name = value !== null && typeof value === "object" && !Array.isArray(value) ? value.name : undefined;
+    throw new Error(`Unknown Herdr tool: ${String(name)}`);
+}
+async function createToolBridge(session, prepared) {
+    const definitions = [...(prepared.customTools ?? []), ...(prepared.resultTool ? [prepared.resultTool] : [])];
+    const bridgeContext = definitions.length ? await createBridgeContext(session, prepared) : undefined;
+    const specs = definitions.map((definition) => {
+        const { name, label, description, promptSnippet, promptGuidelines, parameters, renderShell, executionMode } = definition;
+        return { name, label, description, ...(promptSnippet === undefined ? {} : { promptSnippet }), ...(promptGuidelines === undefined ? {} : { promptGuidelines }), parameters, ...(renderShell === undefined ? {} : { renderShell }), ...(executionMode === undefined ? {} : { executionMode }) };
+    });
+    // NOTE: mkdtemp creates the directory 0700, so only this user can connect to the socket regardless of umask.
+    const bridgeDirectory = mkdtempSync(join(tmpdir(), "pi-herdr-tools-"));
+    const socketPath = join(bridgeDirectory, "bridge.sock");
+    const extensionPath = join(bridgeDirectory, "bridge.mjs");
+    const source = `import net from "node:net";\nconst socketPath = ${JSON.stringify(socketPath)};\nconst tools = ${JSON.stringify(specs)};\nfunction callTool(toolCallId, name, params, signal, onUpdate) {\n  return new Promise((resolve, reject) => {\n    const socket = net.createConnection(socketPath);\n    let buffer = "";\n    let settled = false;\n    const finish = (error, value) => { if (settled) return; settled = true; signal?.removeEventListener("abort", abort); socket.destroy(); error ? reject(error) : resolve(value); };\n    const abort = () => finish(new Error("Herdr tool call aborted"));\n    socket.setEncoding("utf8");\n    socket.on("connect", () => socket.write(JSON.stringify({ toolCallId, name, params }) + "\\n"));\n    socket.on("data", (chunk) => { buffer += chunk.toString(); let newline; while ((newline = buffer.indexOf("\\n")) >= 0) { const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line) continue; let message; try { message = JSON.parse(line); } catch { continue; } if (message.type === "update") onUpdate?.(message.value); else if (message.type === "error") finish(new Error(message.error)); else if (message.type === "result") finish(undefined, message.value); } });\n    socket.on("error", (error) => finish(error));\n    socket.on("close", () => finish(new Error("Herdr tool bridge closed")));\n    signal?.addEventListener("abort", abort, { once: true });\n  });\n}\nfunction reportSettled() {\n  return new Promise((resolve) => {\n    const socket = net.createConnection(socketPath);\n    let buffer = "";\n    let finished = false;\n    const finish = () => { if (finished) return; finished = true; socket.destroy(); resolve(); };\n    socket.setEncoding("utf8");\n    socket.on("connect", () => socket.write(JSON.stringify({ type: "agent_settled" }) + "\\n"));\n    socket.on("data", (chunk) => { buffer += chunk.toString(); let newline; while ((newline = buffer.indexOf("\\n")) >= 0) { const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1); if (!line) continue; try { if (JSON.parse(line).type === "ack") finish(); } catch {} } });\n    socket.on("error", finish);\n    socket.on("close", finish);\n  });\n}\nexport default function(pi) { for (const tool of tools) pi.registerTool({ ...tool, async execute(toolCallId, params, signal, onUpdate) { return callTool(toolCallId, tool.name, params, signal, onUpdate); } }); pi.on("agent_settled", reportSettled); }\n`;
+    writeFileSync(extensionPath, source, { encoding: "utf8", mode: 0o600 });
+    const sockets = new Set();
+    let markSettled = () => { };
+    const settled = new Promise((resolve) => { markSettled = resolve; });
+    const server = createServer((socket) => {
+        sockets.add(socket);
+        const controller = new AbortController();
+        let buffer = "";
+        let handled = false;
+        let reportedSettled = false;
+        const send = (message) => { if (!socket.destroyed)
+            socket.write(`${JSON.stringify(message)}\n`); };
+        const handle = async (value) => {
+            if (handled)
+                return;
+            handled = true;
+            try {
+                if (isLifecycleBridgeRequest(value)) {
+                    reportedSettled = true;
+                    send({ type: "ack" });
+                    return;
+                }
+                const request = toolBridgeRequest(value);
+                const definition = definitions.find(({ name }) => name === request.name);
+                if (!definition) {
+                    send({ type: "error", error: `Unknown Herdr tool: ${request.name}` });
+                    return;
+                }
+                if (!bridgeContext) {
+                    send({ type: "error", error: "Herdr tool bridge context is unavailable" });
+                    return;
+                }
+                const result = await definition.execute(request.toolCallId, request.params, controller.signal, (update) => { send({ type: "update", value: update }); }, bridgeContext(controller.signal, () => { controller.abort(); }));
+                send({ type: "result", value: result });
+            }
+            catch (error) {
+                send({ type: "error", error: errorText(error) });
+            }
+        };
+        const close = () => { controller.abort(); sockets.delete(socket); if (reportedSettled)
+            markSettled(); };
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => { buffer += chunk.toString(); let newline; while ((newline = buffer.indexOf("\n")) >= 0) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            try {
+                void handle(JSON.parse(line));
+            }
+            catch (error) {
+                send({ type: "error", error: errorText(error) });
+            }
+        } });
+        socket.on("close", close);
+        socket.on("error", close);
+    });
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(socketPath, () => { server.removeListener("error", reject); resolve(); }); });
+    let closed = false;
+    return { extensionPath, settled, async close() {
+            if (closed)
+                return;
+            closed = true;
+            markSettled();
+            for (const socket of sockets)
+                socket.destroy();
+            await new Promise((resolve) => server.close(() => { resolve(); }));
+            rmSync(bridgeDirectory, { recursive: true, force: true });
+        } };
+}
+function sessionCommand(session, prepared, prompt, bridges, files, directPrompt) {
+    const runtime = prepared.piRuntime;
+    const entrypoint = runtime?.entrypoint;
+    if (!runtime || typeof runtime.executable !== "string" || !runtime.executable || entrypoint !== undefined && (typeof entrypoint !== "string" || !entrypoint)) {
+        const reason = typeof prepared.piRuntimeError === "string" && prepared.piRuntimeError ? ` (${prepared.piRuntimeError})` : "";
+        const error = new Error(`Herdr cannot launch workflow agent: originating Pi runtime is unavailable${reason}.`);
+        if (reason)
+            error.cause = new Error(prepared.piRuntimeError);
+        throw error;
+    }
+    const source = sessionPath(session.reference);
+    if (!source)
+        throw new Error("Herdr cannot hand off a live session without a transferable session file.");
+    const sessionArg = `--session ${quote(source)}`;
+    const model = `${prepared.model.provider}/${prepared.model.model}${prepared.model.thinking ? `:${prepared.model.thinking}` : ""}`;
+    const toolNames = [...new Set([...prepared.tools, ...(prepared.customTools ?? []).map(({ name }) => name), ...(prepared.resultTool ? [prepared.resultTool.name] : [])])];
+    const tools = toolNames.length ? ` --tools ${quote(toolNames.join(","))}` : " --no-tools";
+    const systemPrompt = prepared.systemPrompt !== undefined ? ` --system-prompt ${quote(files.systemPrompt ?? "")}` : prepared.systemPromptPath ? ` --system-prompt ${quote(prepared.systemPromptPath)}` : "";
+    const appendPrompt = files.appendPrompt ? ` --append-system-prompt ${quote(files.appendPrompt)}` : "";
+    const contextPrompt = files.contextPrompt ? ` --append-system-prompt ${quote(files.contextPrompt)}` : "";
+    const contextFiles = prepared.contextFiles === undefined ? "" : " --no-context-files";
+    const loaded = resourcePaths(session);
+    const allowedSkills = [...new Set([...(prepared.additionalSkillPaths ?? []), ...loaded.skills])];
+    const skills = prepared.resourcePolicy ? ` --no-skills${allowedSkills.map((path) => ` --skill ${quote(path)}`).join("")}` : allowedSkills.map((path) => ` --skill ${quote(path)}`).join("");
+    const allowedExtensions = [...new Set(loaded.extensions)];
+    const bridgeExtensions = bridges.filter(Boolean).map(({ extensionPath }) => ` --extension ${quote(extensionPath)}`).join("");
+    const extensions = prepared.resourcePolicy ? ` --no-extensions${allowedExtensions.map((path) => ` --extension ${quote(path)}`).join("")}${bridgeExtensions}` : bridgeExtensions;
+    const trust = prepared.resourcePolicy?.projectTrusted === false ? " --no-approve" : prepared.resourcePolicy?.projectTrusted === true ? " --approve" : "";
+    const environment = [prepared.agentDir ? `PI_CODING_AGENT_DIR=${quote(prepared.agentDir)}` : "", `PI_EXTENSIBLE_WORKFLOWS_SETTINGS_FILE=${quote(files.settingsFile)}`, "PI_EXTENSIBLE_WORKFLOWS_HERDR_OWNER=1"].filter(Boolean).join(" ");
+    const message = prompt === undefined ? "" : directPrompt ? ` ${quote(prompt)}` : ` @${quote(files.prompt ?? "")}`;
+    return `${environment} ${quote(runtime.executable)}${entrypoint ? ` ${quote(entrypoint)}` : ""} ${sessionArg} --model ${quote(model)}${tools}${systemPrompt}${appendPrompt}${contextPrompt}${contextFiles}${skills}${extensions}${trust}${message}`;
+}
+function paneId(value) { return typeof value === "string" ? value : value.paneId; }
+function workspacePane(value) {
+    if (typeof value === "string")
+        throw new Error("Herdr did not create a workspace pane.");
+    return value;
+}
+function createWorkflowWorkspaces(runner) {
+    const workspaces = new Map();
+    return {
+        async open(run, request) {
+            const existing = workspaces.get(run.runId);
+            if (existing)
+                return workspacePane(await openHerdrLivePane({ ...request, workspaceId: await existing }, runner));
+            const opening = openHerdrLivePane({ ...request, workspaceLabel: `workflow ${run.workflow.name}` }, runner);
+            const workspace = opening.then((pane) => {
+                if (typeof pane === "string")
+                    throw new Error("Herdr did not create a workspace pane.");
+                return pane.workspaceId;
+            });
+            workspaces.set(run.runId, workspace);
+            try {
+                return workspacePane(await opening);
+            }
+            catch (error) {
+                workspaces.delete(run.runId);
+                await workspace.catch(() => undefined);
+                throw error;
+            }
+        },
+        async close(runId) {
+            const workspace = workspaces.get(runId);
+            workspaces.delete(runId);
+            if (workspace)
+                await workspace.then((id) => runner(["workspace", "close", id])).catch(() => undefined);
+        },
+        async closeAll() { await Promise.all([...workspaces.keys()].map((runId) => this.close(runId))); },
+    };
+}
+async function launchPane({ session, prepared, identity, run, attempt, runner, fullyInspectable, env, signal, prompt, workspaces, tuiIndex, tuiLabel, directPrompt = false, onStatus }) {
+    const label = fullyInspectable && typeof tuiIndex === "number" && Number.isInteger(tuiIndex) && tuiIndex > 0 && typeof tuiLabel === "string" && tuiLabel.trim() ? `#${String(tuiIndex)} ${tuiLabel}` : fullyInspectable ? breadcrumbLabel(identity, attempt) : prepared.sessionLabel;
+    const bridge = await createToolBridge(session, prepared);
+    let inlineBridge;
+    let commandFiles;
+    let pane;
+    try {
+        inlineBridge = createInlineExtensionBridge(prepared);
+        const selectedContextFiles = prepared.contextFiles === undefined ? undefined : session.getHerdrContextFiles?.() ?? [];
+        commandFiles = createCommandFiles(prepared, prompt, directPrompt, selectedContextFiles);
+        const bridges = [inlineBridge, bridge].filter((value) => Boolean(value));
+        const command = commandFiles.command(sessionCommand(session, prepared, prompt, bridges, commandFiles, directPrompt));
+        let opened;
+        if (fullyInspectable) {
+            if (!workspaces || !run)
+                throw new Error("Herdr fully inspectable mode is missing its workspace context.");
+            opened = await workspaces.open(run, { cwd: prepared.cwd, tabLabel: label, command });
+        }
+        else {
+            opened = await openHerdrLivePane({ action: "live", cwd: prepared.cwd, command, ...(env.HERDR_PANE_ID ? { paneId: env.HERDR_PANE_ID } : {}) }, runner);
+        }
+        pane = paneId(opened);
+        if (!pane)
+            throw new Error("Herdr did not create a pane.");
+        let remoteClosed = false;
+        const openedPane = pane;
+        const closeRemote = async () => {
+            if (remoteClosed)
+                return;
+            remoteClosed = true;
+            await runner(fullyInspectable && typeof opened !== "string" ? ["tab", "close", opened.tabId] : ["pane", "close", openedPane]).catch(() => undefined);
+        };
+        const reporter = createHerdrAgentReporter(openedPane, label, runner);
+        const reference = session.reference;
+        const path = sessionPath(reference);
+        const sessionRef = path ? { sessionId: reference.sessionId, sessionPath: path } : { sessionId: reference.sessionId };
+        try {
+            await reporter.reportSession(sessionRef, "workflow-agent");
+        }
+        catch (error) {
+            await closeRemote();
+            throw error;
+        }
+        const monitorController = new AbortController();
+        const abortMonitor = () => { monitorController.abort(); };
+        if (signal.aborted)
+            abortMonitor();
+        else
+            signal.addEventListener("abort", abortMonitor, { once: true });
+        let cleanup;
+        const closeResources = () => cleanup ??= (async () => {
+            await reporter.release();
+            await bridge.close();
+            await inlineBridge?.close();
+            await commandFiles?.close();
+        })();
+        const monitor = waitForHerdrPane(openedPane, runner, { signal: monitorController.signal, ...(bridge.settled ? { settled: bridge.settled } : {}), ...(prepared.piRuntime?.entrypoint ? { originatingEntrypoint: prepared.piRuntime.entrypoint } : {}), ...(onStatus ? { onStatus } : {}) }).then(async (reason) => {
+            await closeRemote();
+            await closeResources();
+            return reason;
+        }).catch(async (error) => {
+            await closeRemote();
+            await closeResources().catch(() => undefined);
+            throw error;
+        }).finally(() => { signal.removeEventListener("abort", abortMonitor); });
+        return { pane: openedPane, monitor, reporter, closeRemote, close: async () => { monitorController.abort(); await monitor.then(() => undefined, () => undefined); } };
+    }
+    catch (error) {
+        if (pane && !fullyInspectable)
+            await runner(["pane", "close", pane]).catch(() => undefined);
+        await bridge.close();
+        await inlineBridge?.close();
+        await commandFiles?.close();
+        throw error;
+    }
+}
+function herdrTransport(agent, context, runner, fullyInspectable, env, workspaces) {
+    const local = agent.transport;
+    const transport = {
+        id: "herdr",
+        async createSession(prepared, sessionContext) {
+            const session = await local.createSession(prepared, sessionContext);
+            const suspendAndLaunch = async (prompt) => {
+                let suspended = false;
+                try {
+                    if (session.suspendForHandoff) {
+                        await session.suspendForHandoff();
+                        suspended = true;
+                    }
+                    else {
+                        await session.abort();
+                        suspended = true;
+                    }
+                    materializeSessionForHandoff(session, prepared);
+                    return await launchPane({ session, prepared, identity: context.identity, run: context.run, attempt: sessionContext.attempt, runner, fullyInspectable, env, signal: sessionContext.signal, prompt, workspaces, tuiIndex: context.tuiIndex, tuiLabel: context.tuiLabel });
+                }
+                catch (error) {
+                    if (suspended) {
+                        try {
+                            await session.resumeFromHandoff?.();
+                        }
+                        catch { /* Preserve the pane launch failure. */ }
+                    }
+                    throw error;
+                }
+            };
+            const inFlight = new Set();
+            let disposed = false;
+            const isDisposed = () => disposed;
+            let sharedLaunch;
+            const beginLaunch = (prompt, retry = false) => {
+                if (isDisposed())
+                    return Promise.reject(new Error("Herdr workflow session is disposed"));
+                // Joined callers share the first launch; the executor normally serializes prompts, so later text is not sent separately.
+                if (sharedLaunch)
+                    return sharedLaunch;
+                const next = (async () => {
+                    try {
+                        return await suspendAndLaunch(prompt);
+                    }
+                    catch (error) {
+                        if (!retry || isDisposed())
+                            throw error;
+                        return suspendAndLaunch(prompt);
+                    }
+                })();
+                sharedLaunch = next;
+                inFlight.add(next);
+                void next.then(() => { inFlight.delete(next); if (sharedLaunch === next)
+                    sharedLaunch = undefined; }, () => { inFlight.delete(next); if (sharedLaunch === next)
+                    sharedLaunch = undefined; });
+                return next;
+            };
+            let opened;
+            try {
+                opened = await beginLaunch(prepared.initialPrompt);
+            }
+            catch (error) {
+                await session.dispose().catch(() => undefined);
+                throw error;
+            }
+            let disposal;
+            let active = opened;
+            return {
+                ...session,
+                getLastAssistant() { return session.getLastAssistant?.call(this); },
+                reference: { ...session.reference, transport: "herdr" },
+                async prompt(text) {
+                    if (disposed)
+                        throw new Error("Herdr workflow session is disposed");
+                    let current = active;
+                    if (!current) {
+                        const pending = inFlight.values().next().value;
+                        current = pending ? await pending : await beginLaunch(text, true);
+                    }
+                    active = current;
+                    let monitorFailed = false;
+                    let monitorError;
+                    let resumeFailed = false;
+                    let resumeError;
+                    try {
+                        await current.monitor;
+                    }
+                    catch (error) {
+                        monitorFailed = true;
+                        monitorError = error;
+                    }
+                    finally {
+                        try {
+                            await session.resumeFromHandoff?.();
+                        }
+                        catch (error) {
+                            resumeFailed = true;
+                            resumeError = error;
+                        }
+                        finally {
+                            if (active === current)
+                                active = undefined;
+                        }
+                    }
+                    if (monitorFailed)
+                        throw monitorError;
+                    if (resumeFailed)
+                        throw resumeError;
+                    let assistant = session.getLastAssistant?.();
+                    const resultTool = prepared.resultTool;
+                    const resultSubmitted = resultTool !== undefined && hasNamedToolCall(assistant, resultTool.name);
+                    const incomplete = needsContinuation(assistant);
+                    if (!resultSubmitted && incomplete) {
+                        await session.prompt("Continue the task from the current session state.");
+                        assistant = session.getLastAssistant?.();
+                    }
+                    return assistant ? { assistant } : {};
+                },
+                async abort() { await session.abort(); },
+                async dispose() {
+                    if (disposal) {
+                        await disposal;
+                        return;
+                    }
+                    disposed = true;
+                    disposal = (async () => {
+                        const pendingLaunches = [...inFlight];
+                        if (pendingLaunches.length > 0) {
+                            const results = await Promise.allSettled(pendingLaunches);
+                            if (!active) {
+                                for (const result of results) {
+                                    if (result.status === "fulfilled") {
+                                        active = result.value;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (active) {
+                            await active.closeRemote();
+                            await active.close();
+                        }
+                        await session.dispose();
+                    })();
+                    await disposal;
+                }
+            };
+        },
+    };
+    return transport;
+}
+async function abortSession(session) { await session.abort?.(); }
+function hasExtensionHooks(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.on === "function" && typeof candidate.events?.on === "function";
+}
+function isHerdrBlockedEvent(value) {
+    return value !== null && typeof value === "object" && typeof value.active === "boolean" && (value.label === undefined || typeof value.label === "string");
+}
+function registerLifecycleHooks(pi, runner, env) {
+    const pane = env.HERDR_PANE_ID;
+    if (!pane || !hasExtensionHooks(pi))
+        return;
+    pi.events.on(WORKFLOW_BLOCKED_EVENT, (data) => { if (isHerdrBlockedEvent(data))
+        pi.events.emit("herdr:blocked", data); });
+    const liveRunIds = new Set();
+    const setLiveRun = (runId, active) => { const before = liveRunIds.size; if (active)
+        liveRunIds.add(runId);
+    else
+        liveRunIds.delete(runId); if (liveRunIds.size !== before)
+        pi.events.emit("herdr:working", { runId, active }); };
+    pi.events.on(WORKFLOW_RUN_STARTED_EVENT, (event) => { if (isRunEvent(event))
+        setLiveRun(event.runId, true); });
+    pi.events.on(WORKFLOW_RUN_RESUMED_EVENT, (event) => { if (isRunEvent(event))
+        setLiveRun(event.runId, true); });
+    pi.events.on(WORKFLOW_RUN_COMPLETED_EVENT, (event) => { if (isRunEvent(event))
+        setLiveRun(event.runId, false); });
+    pi.events.on(WORKFLOW_RUN_FAILED_EVENT, (event) => { if (isRunEvent(event))
+        setLiveRun(event.runId, false); });
+    pi.events.on(WORKFLOW_RUN_STATE_CHANGED_EVENT, (event) => {
+        if (!isRunEvent(event))
+            return;
+        const state = event.state;
+        if (state !== undefined)
+            setLiveRun(event.runId, isLiveRunActiveState(state));
+    });
+    if (env.PI_EXTENSIBLE_WORKFLOWS_HERDR_OWNER !== "1")
+        return;
+    const reporter = createHerdrAgentReporter(pane, "pi", runner);
+    let sessionRef = {};
+    let rootSession = false;
+    let agentActive = false;
+    let blockedCount = 0;
+    let blockedMessage;
+    let lastState;
+    let lastMessage;
+    let queuedState;
+    let stateReport = Promise.resolve();
+    const refresh = (ctx) => {
+        const path = ctx.sessionManager.getSessionFile();
+        const id = ctx.sessionManager.getSessionId();
+        sessionRef = { ...(typeof id === "string" ? { sessionId: id } : {}), ...(typeof path === "string" ? { sessionPath: path } : {}) };
+        return sessionRef;
+    };
+    const desiredState = () => blockedCount > 0 ? { state: "blocked", message: blockedMessage } : agentActive || liveRunIds.size > 0 ? { state: "working", message: undefined } : { state: "idle", message: undefined };
+    const drainState = async () => {
+        while (queuedState) {
+            const next = queuedState;
+            queuedState = undefined;
+            await reporter.reportState(next.state, next.message, sessionRef);
+        }
+    };
+    const publishState = (force = false) => {
+        const next = desiredState();
+        if (!force && next.state === lastState && next.message === lastMessage)
+            return;
+        lastState = next.state;
+        lastMessage = next.message;
+        queuedState = next;
+        stateReport = stateReport.then(drainState, drainState);
+    };
+    pi.events.on("herdr:working", () => { if (rootSession)
+        publishState(); });
+    pi.events.on("herdr:blocked", (data) => {
+        if (!rootSession)
+            return;
+        const blocked = isHerdrBlockedEvent(data) ? data : { active: false };
+        if (!blocked.active) {
+            blockedCount = Math.max(0, blockedCount - 1);
+            if (blockedCount === 0)
+                blockedMessage = undefined;
+        }
+        else {
+            blockedCount += 1;
+            blockedMessage = blocked.label;
+        }
+        publishState();
+    });
+    pi.on("session_start", async (event, ctx) => {
+        rootSession = true;
+        refresh(ctx);
+        await reporter.reportSession(sessionRef, event.reason);
+        agentActive = !ctx.isIdle();
+        publishState(true);
+        await stateReport;
+    });
+    pi.on("agent_start", async (_event, ctx) => {
+        if (!rootSession)
+            return;
+        refresh(ctx);
+        await reporter.reportSession(sessionRef);
+        agentActive = true;
+        publishState();
+        await stateReport;
+    });
+    pi.on("turn_end", async (event) => {
+        if (!rootSession)
+            return;
+        agentActive = hasToolCall(event.message) && !hasNamedToolCall(event.message, "workflow_result");
+        publishState();
+        await stateReport;
+    });
+    pi.on("agent_settled", async () => { if (!rootSession)
+        return; agentActive = false; publishState(); await stateReport; });
+    pi.on("agent_end", async (_event, ctx) => { if (!rootSession || !ctx.isIdle())
+        return; agentActive = false; publishState(); await stateReport; });
+    pi.on("session_shutdown", async (event) => { if (event.reason === "quit")
+        await reporter.release(); });
+}
+export function createHerdrExtension(options = {}) {
+    const env = options.env ?? process.env;
+    const runner = options.runner ?? herdrCommandRunner;
+    const workspaces = options.workspaces ?? createWorkflowWorkspaces(runner);
+    const fullyInspectable = isFullyInspectableMode(options.agentDir);
+    const fullyInspectableFor = (settings) => settings === undefined ? fullyInspectable : settings.herdr?.enableFullyInspectableMode === true;
+    const sessionCwd = (context) => completedSessionCwd("run" in context ? context : { attempt: context.attempt });
+    const actionIdentity = (context) => {
+        const parentBreadcrumb = "run" in context ? context.agent.parentBreadcrumb : undefined;
+        return { structuralPath: context.agent.structuralPath ?? [], ...(parentBreadcrumb ? { parentBreadcrumb } : {}), callSite: context.agent.label ?? context.agent.name, occurrence: context.attempt.attempt };
+    };
+    const openSessionVisible = (context) => herdrAvailable(env) && !context.liveSession && (context.agent.state === "completed" || context.agent.state === "failed" || context.agent.state === "cancelled" || context.agent.state === "stopped") && Boolean(context.session?.sessionId && sessionCwd(context));
+    const openSession = async (context) => {
+        const session = context.session;
+        const cwd = sessionCwd(context);
+        if (!session || context.liveSession || !cwd)
+            return;
+        await openHerdrLivePane({ action: "live", cwd, command: inspectSessionCommand(session), ...(env.HERDR_PANE_ID ? { paneId: env.HERDR_PANE_ID } : {}) }, runner);
+    };
+    const openLiveVisible = (context) => herdrAvailable(env) && !fullyInspectableFor(context.prepared?.settings) && Boolean(context.liveSession && sessionPath(context.liveSession.reference) && context.prepared && context.handoff);
+    const openLive = async (context) => {
+        const session = context.liveSession;
+        const prepared = context.prepared;
+        const handoff = context.handoff;
+        if (!session || !prepared || !handoff)
+            return;
+        if (!sessionPath(session.reference))
+            throw new Error("Herdr cannot hand off a live session without a transferable session file.");
+        const label = typeof context.agent.label === "string" && context.agent.label.trim() ? context.agent.label : typeof context.agent.name === "string" && context.agent.name.trim() ? context.agent.name : "workflow agent";
+        let lastWorkingMessage;
+        const setWorkingMessage = (state) => {
+            const message = state ? `${label}: ${state}` : undefined;
+            if (message === lastWorkingMessage)
+                return;
+            lastWorkingMessage = message;
+            context.ui.setWorkingMessage?.(message);
+        };
+        const handoffReleased = () => handoff.state === "completed";
+        const handoffCancelled = () => context.signal.aborted || handoffReleased();
+        setWorkingMessage("queued (waiting for a turn boundary)");
+        await handoff.request(async () => {
+            setWorkingMessage("opening pane");
+            const continueTask = needsContinuation(session.getLastAssistant());
+            let opened;
+            let suspended = false;
+            let reportedWorking = false;
+            let lastState = "working";
+            let displayedState;
+            const reportStatus = (state) => {
+                lastState = state;
+                if (state === "working")
+                    reportedWorking = true;
+                if (displayedState !== state) {
+                    displayedState = state;
+                    setWorkingMessage(state);
+                }
+            };
+            try {
+                await abortSession(session);
+                if (handoffCancelled())
+                    return;
+                if (session.suspendForHandoff)
+                    await session.suspendForHandoff();
+                suspended = true;
+                if (handoffCancelled())
+                    return;
+                opened = await launchPane({ session, prepared, identity: actionIdentity(context), attempt: context.attempt.attempt, runner, fullyInspectable: false, env, signal: context.signal, prompt: continueTask ? "Continue the current workflow task from this session." : undefined, directPrompt: continueTask, onStatus: reportStatus });
+                if (handoffCancelled()) {
+                    if (handoffReleased())
+                        await opened.closeRemote().catch(() => undefined);
+                    await opened.monitor;
+                    return;
+                }
+                handoff.takeover();
+                if (displayedState === undefined || lastState === "idle") {
+                    displayedState = "working";
+                    setWorkingMessage("working");
+                    reportedWorking = true;
+                }
+                await opened.monitor;
+            }
+            finally {
+                try {
+                    if (reportedWorking)
+                        setWorkingMessage(lastState === "done" ? "completed" : "idle");
+                }
+                finally {
+                    try {
+                        if (suspended)
+                            await session.resumeFromHandoff?.();
+                    }
+                    finally {
+                        if (reportedWorking) {
+                            await new Promise((resolve) => setTimeout(resolve, 50));
+                            setWorkingMessage();
+                        }
+                    }
+                }
+            }
+        }).finally(() => { setWorkingMessage(); });
+    };
+    const validateSettings = (settings) => {
+        const value = settings?.herdr;
+        if (value === undefined)
+            return;
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            throw new Error("herdr settings must be an object");
+        const keys = Object.keys(value);
+        if (keys.some((key) => key !== "enableFullyInspectableMode"))
+            throw new Error("unsupported herdr setting");
+        if ("enableFullyInspectableMode" in value && typeof value.enableFullyInspectableMode !== "boolean")
+            throw new Error("enableFullyInspectableMode must be a boolean");
+    };
+    return {
+        version: "1.0.0",
+        headline: "Herdr workflow integration",
+        validateSettings,
+        agentAttemptActions: {
+            openSession: {
+                label: "Open session in Herdr pane",
+                visible: openSessionVisible,
+                run: openSession,
+                visibleStandalone: openSessionVisible,
+                runStandalone: openSession,
+            },
+            openLiveSession: {
+                label: "Open live session in Herdr pane",
+                visible: openLiveVisible,
+                run: openLive,
+                visibleStandalone: openLiveVisible,
+                runStandalone: openLive,
+            },
+        },
+        agentSetupHooks: {
+            fullyInspectable: {
+                setup(agent, context) {
+                    if (context.mode === "inspection" || !fullyInspectableFor(context.settings) || !herdrAvailable(env))
+                        return;
+                    agent.transport = herdrTransport(agent, context, runner, true, env, workspaces);
+                },
+            },
+        },
+    };
+}
+export function registerHerdrExtension(options = {}) {
+    const env = options.env ?? process.env;
+    if (!herdrAvailable(env))
+        return false;
+    registerWorkflowExtension(createHerdrExtension(options));
+    return true;
+}
+function isRunEvent(value) {
+    return value !== null && typeof value === "object" && typeof value.runId === "string";
+}
+function isTerminalRunState(value) {
+    return value === "failed" || value === "stopped" || value === "interrupted" || value === "budget_exhausted";
+}
+function isLiveRunActiveState(value) { return value === "running" || value === "pausing"; }
+function registerWorkspaceLifecycle(pi, workspaces) {
+    if (!hasExtensionHooks(pi))
+        return;
+    pi.events.on(WORKFLOW_RUN_COMPLETED_EVENT, (event) => { if (isRunEvent(event))
+        void workspaces.close(event.runId); });
+    pi.events.on(WORKFLOW_RUN_STATE_CHANGED_EVENT, (event) => { if (isRunEvent(event) && isTerminalRunState(event.state))
+        void workspaces.close(event.runId); });
+    pi.on("session_shutdown", async () => { await workspaces.closeAll(); });
+}
+export default function extension(pi, overrides = {}) {
+    const runner = overrides.runner ?? herdrCommandRunner;
+    const workspaces = overrides.workspaces ?? createWorkflowWorkspaces(runner);
+    const options = { env: overrides.env ?? process.env, runner, workspaces };
+    if (registerHerdrExtension(options)) {
+        registerLifecycleHooks(pi, runner, options.env);
+        registerWorkspaceLifecycle(pi, workspaces);
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@marcoscale98/piewf-herdr",
+  "version": "5.14.1-fork.1",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "test": "npm run build && node --test --test-timeout=120000 --test-force-exit test/index.test.mjs",
+    "prepack": "npm run build",
+    "lint": "eslint ."
+  },
+  "pi": {
+    "extensions": ["./dist/index.js"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@marcoscale98/pi-extensible-workflows": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marcoscale98/pi-extensible-workflows.git",
+    "directory": "packages/extensions/herdr"
+  },
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./index.js": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "0.85.0",
+    "@types/node": "24.12.4",
+    "typescript": "5.9.3"
+  }
+}