@vibesdotdev/integrations-pi 0.0.0-stage → 1.0.0-rc.1

package/dist/extension/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @vibesdotdev/integrations-pi/extension/bun
+ *
+ * Pi extension factory. Duck-types ExtensionAPI so this file stays importable
+ * without @earendil-works/pi-coding-agent.
+ *
+ * Pi uses the Vibes runtime exactly as the CLI does, in-process: at
+ * session_start, with Pi's actual workspace, the extension boots one runtime
+ * (the CLI app on the Node host environment, `./runtime-host.ts`) that finds
+ * the workspace's vibes config and composes its plugins. The catalog is that
+ * runtime's `tools/tool` registry; tools run through the same caller path as
+ * `vibes tools run`; slash commands and the session bind run as CLI commands
+ * in that runtime. There is no daemon socket and no CLI child.
+ *
+ * No tool list lives here. Registration is all-or-nothing: the whole
+ * projection is validated before the first registerTool call, so a name
+ * collision cannot leave Pi with half a harness. The system prompt is
+ * generated from the names actually registered, which are the underscore
+ * projections - naming the registry ids here would point the model at tools
+ * that do not exist in Pi.
+ */
+import { type LiveToolDescriptor, type NormalizedLiveTool } from '@vibesdotdev/external/consumer/node/harness';
+import { PI_BUILTIN_TOOLS, toPiToolName } from '../harness/pi-naming.ts';
+import { type PiToolPolicyProfile } from '../harness/constants.ts';
+export { PI_BUILTIN_TOOLS, toPiToolName };
+export { buildLivePiHarnessPrompt } from '../harness/prompt.ts';
+export { PiCatalogError } from '../harness/pi-naming.ts';
+export { bootPiRuntime, resolvePiHostRoot, type PiRuntimeHost } from './runtime-host.ts';
+export type { LiveToolDescriptor, NormalizedLiveTool };
+/** Deprecated alias: the canonical type is the shared live descriptor. */
+export type VibesHarnessTool = LiveToolDescriptor;
+/** Deprecated alias: the canonical type is host-neutral. */
+export type VibesOpencodeTool = LiveToolDescriptor;
+import type { PiExtensionAPI, CreatePiExtensionOptions } from '../schemas/extension-api.ts';
+export type { PiRuntimeHostOptions } from './runtime-host.ts';
+export type { PiTypeField, PiExtensionAPI, PiToolResult, CreatePiExtensionOptions } from '../schemas/extension-api.ts';
+export declare function createVibesPiExtension(options: CreatePiExtensionOptions): (pi: PiExtensionAPI) => Promise<{
+    /** Joins the current activation without blocking the native session_start callback. */
+    whenReady: () => Promise<void>;
+}>;
+/**
+ * settings.json projection for a tool policy. `defaultTools` is omitted for
+ * `native`, which leaves the host default untouched; Pi keeps extension tools
+ * either way.
+ */
+export declare function piSettingsForProfile(profile?: PiToolPolicyProfile, extensionRef?: string): Record<string, import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined>;
+/** Default projection used by the installer: builtins off, extension loaded. */
+export declare const VIBES_PI_SETTINGS: Record<string, import("@vibesdotdev/kernel/bootstrap").JsonValue | undefined>;
+/**
+ * Default factory Pi loads from `.pi/extensions/vibes.ts`. This module is the
+ * host entry inside the Pi process, so it hands in Pi's own environment.
+ */
+export { default } from './entry.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/extension/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extension/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA6BH,OAAO,EAKN,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EACN,gBAAgB,EAEhB,YAAY,EAEZ,MAAM,yBAAyB,CAAC;AAIjC,OAAO,EAGN,KAAK,mBAAmB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,CAAC;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACzF,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;AACvD,0EAA0E;AAC1E,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,CAAC;AAClD,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAgB,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC1G,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAoBvH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,IAKhC,IAAI,cAAc;IAibvD,uFAAuF;qBAClE,OAAO,CAAC,IAAI,CAAC;GAGpC;AASD;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,GAAE,mBAAoD,EAC7D,YAAY,SAA0B,iFAMtC;AAED,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,+EAAmC,CAAC;AAElE;;;GAGG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}

package/dist/extension/index.js

@@ -0,0 +1,547 @@
+/**
+ * @vibesdotdev/integrations-pi/extension/bun
+ *
+ * Pi extension factory. Duck-types ExtensionAPI so this file stays importable
+ * without @earendil-works/pi-coding-agent.
+ *
+ * Pi uses the Vibes runtime exactly as the CLI does, in-process: at
+ * session_start, with Pi's actual workspace, the extension boots one runtime
+ * (the CLI app on the Node host environment, `./runtime-host.ts`) that finds
+ * the workspace's vibes config and composes its plugins. The catalog is that
+ * runtime's `tools/tool` registry; tools run through the same caller path as
+ * `vibes tools run`; slash commands and the session bind run as CLI commands
+ * in that runtime. There is no daemon socket and no CLI child.
+ *
+ * No tool list lives here. Registration is all-or-nothing: the whole
+ * projection is validated before the first registerTool call, so a name
+ * collision cannot leave Pi with half a harness. The system prompt is
+ * generated from the names actually registered, which are the underscore
+ * projections - naming the registry ids here would point the model at tools
+ * that do not exist in Pi.
+ */
+import { getRuntimePath } from '@vibesdotdev/paths';
+import { getLogger } from '@vibesdotdev/logging';
+import { PiExtensionEventSchema, PiStringSchema, PiHostContextSchema, PiToolCallEventSchema, PiJsonSchema, PiKernelInputSchema } from "../schemas/extension.js";
+import { PiSettingsSchema } from "../schemas/installer.js";
+import { parseOutput, renderCall, renderResult } from "./render.js";
+import { projectVirtualModels } from "./models.js";
+import { renderAgentRolePrompt } from '@vibesdotdev/external/harness';
+import { forwardRuntimeEvents } from "./events.js";
+import { applyVibesPiChrome, bindVibesSession, confirmMutatingTool } from "./chrome.js";
+import { getPiApprovalMemory, approvalPosture } from "./approvals.js";
+import { runVibesPiCommand, piCommandSpecs } from "./commands.js";
+import { activatePiSearchHits, PI_INITIAL_TOOL_IDS, restrictPiToolsToDiscovery } from "./active-tools.js";
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure, settle, settleNow } from '@vibesdotdev/kernel';
+import { bootPiRuntime } from "./runtime-host.js";
+import { LiveToolDescriptorSchema, HostToolInputSchema, normalizeLiveTool } from '@vibesdotdev/external/consumer/node/harness';
+import { PI_BUILTIN_TOOLS, assertPiToolCatalog, toPiToolName } from "../harness/pi-naming.js";
+import { buildLivePiHarnessPrompt } from "../harness/prompt.js";
+import { declarePiAgentIdentity, PI_HARNESS_ID } from "../harness/identity.js";
+import { DEFAULT_PI_TOOL_POLICY_PROFILE, piDefaultToolsForProfile } from "../harness/constants.js";
+export { PI_BUILTIN_TOOLS, toPiToolName };
+export { buildLivePiHarnessPrompt } from "../harness/prompt.js";
+export { PiCatalogError } from "../harness/pi-naming.js";
+export { bootPiRuntime, resolvePiHostRoot } from "./runtime-host.js";
+/** A tool's answer as Pi's text; an answer with nothing in it says so, as the CLI does. */
+function toolText(output) {
+    if (output === undefined || output === '')
+        return '(no output)';
+    return PiStringSchema.safeParse(output).data ?? JSON.stringify(output, null, 2);
+}
+/**
+ * The model's tool arguments as the host boundary accepts them.
+ *
+ * Pi hands over whatever the model produced, so the JSON is decoded here rather
+ * than forwarded as `unknown`. An argument that is not JSON is the tool's own
+ * validation to reject with its message; this only decides what a tool call
+ * carries.
+ */
+function hostToolInput(params) {
+    return HostToolInputSchema.parse(params ?? {});
+}
+export function createVibesPiExtension(options) {
+    const reserved = options.reservedNames ?? PI_BUILTIN_TOOLS;
+    const injectSystemPrompt = options.injectSystemPrompt !== false;
+    const bootRuntime = options.bootRuntime ?? bootPiRuntime;
+    return async function vibesPiExtension(pi) {
+        // Name the Pi body before its runtime boots. Every agent-scoped organ
+        // (brain, presence, memories) stores per body and refuses an unnamed
+        // caller. An explicit VIBES_AGENT_ID still wins: see ../harness/identity.ts.
+        declarePiAgentIdentity(options.hostEnv);
+        let current;
+        let pendingHost;
+        // The activation session_start began. Pi starts a session at every startup, so a slash command
+        // typed before that, or while the runtime boots, runs once the activation lands.
+        let activation;
+        // Held in an object: resolving with the activation itself would adopt (and so raise) its failure.
+        let announceActivation = () => { };
+        const firstActivation = new Promise((resolve) => { announceActivation = resolve; });
+        // Who calls: this harness and its own conversation. Caller admission keys
+        // the seat (instance, participant, session) on them, so a call names its
+        // conversation and never pins a session: a `session init` the model makes
+        // moves the seat, and the next call follows it.
+        const harnessOf = (ctx) => ({
+            harness: options.hostEnv?.VIBES_HARNESS?.trim() || PI_HARNESS_ID,
+            harnessSessionId: ctx?.sessionManager?.getSessionId()
+        });
+        const bindSession = (selected, ctx) => {
+            selected.binding ??= (async () => {
+                const bound = await bindVibesSession(selected.host, ctx?.ui, harnessOf(ctx), selected.sessionId);
+                if (current === selected)
+                    selected.sessionId = bound;
+                return bound;
+            })();
+            return selected.binding;
+        };
+        const posture = options.approvalPosture ?? approvalPosture(options.hostEnv);
+        let generation = 0;
+        let disposed = false;
+        /** Stops the runtime event forwarders the live activation installed. */
+        let stopEventForwarding = [];
+        const ownedNames = new Set();
+        /** Unregisters the virtual models the live activation projected. */
+        let unprojectModels = () => { };
+        const sessionFor = (ctx) => {
+            if (!current || disposed)
+                throw new CapabilityError('Vibes session workspace is not ready', 'UNAVAILABLE', { reason: 'pi-session-not-ready' });
+            if (ctx?.cwd && current.cwd !== current.paths.resolve(ctx.cwd))
+                throw new CapabilityError('Vibes tool context does not match the current session workspace', 'CONFLICT', { reason: 'pi-workspace-mismatch' });
+            return current;
+        };
+        const deactivateOwned = () => {
+            if (ownedNames.size > 0 && pi.getActiveTools && pi.setActiveTools)
+                pi.setActiveTools(pi.getActiveTools().filter((name) => !ownedNames.has(name)));
+            unprojectModels();
+            unprojectModels = () => { };
+            for (const stop of stopEventForwarding)
+                stop();
+            stopEventForwarding = [];
+        };
+        const activate = async (cwd, initialCatalog) => {
+            const priorActivation = activation;
+            const revision = ++generation;
+            const workspaceRoot = cwd;
+            // Same workspace, same runtime: keep the host Pi already booted.
+            // Pi fires session_start at every startup even when the workspace
+            // has not changed; re-booting costs ~16 seconds for nothing.
+            if (workspaceRoot && current?.cwd === workspaceRoot && !disposed && generation === revision) {
+                register(current.entries, current.toolByName);
+                return current;
+            }
+            const previous_ = current;
+            current = undefined;
+            deactivateOwned();
+            const previousPending = pendingHost;
+            pendingHost = undefined;
+            await previous_?.host.dispose();
+            if (priorActivation) {
+                const settled = await settle(() => priorActivation);
+                if (!settled.ok)
+                    reportFailure('Previous Pi activation failed', settled.cause, {});
+            }
+            if (previousPending) {
+                const pending = await settle(() => previousPending);
+                if (pending.ok)
+                    await pending.value.dispose();
+                else
+                    reportFailure('Previous Pi boot failed', pending.cause, {});
+            }
+            if (disposed || generation !== revision)
+                return;
+            if (!workspaceRoot)
+                throw new CapabilityError('Pi host did not provide a session workspace directory', 'INVALID_INPUT', { reason: 'pi-workspace-required' });
+            const booting = bootRuntime(options.hostRoot === undefined ? { cwd: workspaceRoot, hostEnv: options.hostEnv } : { cwd: workspaceRoot, hostEnv: options.hostEnv, hostRoot: options.hostRoot });
+            pendingHost = booting;
+            let host;
+            try {
+                host = await booting;
+            }
+            catch (cause) {
+                if (pendingHost === booting)
+                    pendingHost = undefined;
+                throw new CapabilityError('Pi runtime activation failed.', 'UNAVAILABLE', { reason: 'pi-activation-failed', cause });
+            }
+            if (pendingHost === booting)
+                pendingHost = undefined;
+            if (disposed || generation !== revision) {
+                await host.dispose();
+                return;
+            }
+            // A catalog this host cannot project fails the activation, and the host it booted goes with it.
+            const projected = settleNow(() => {
+                const normalized = (initialCatalog ?? host.catalog()).map((descriptor) => normalizeLiveTool(LiveToolDescriptorSchema.parse(descriptor)));
+                return { entries: assertEntries(normalized, reserved), toolByName: new Map(normalized.map((tool) => [toPiToolName(tool.id), tool])) };
+            });
+            if (!projected.ok) {
+                await host.dispose();
+                throw new CapabilityError('Pi tool activation failed.', 'UNAVAILABLE', { reason: 'pi-activation-failed', cause: projected.cause });
+            }
+            const { entries, toolByName } = projected.value;
+            const paths = await getRuntimePath(host.runtime);
+            if (disposed || generation !== revision) {
+                await host.dispose();
+                return;
+            }
+            current = {
+                paths,
+                cwd: paths.resolve(workspaceRoot),
+                sessionId: options.hostEnv?.VIBES_SESSION_ID?.trim() || undefined,
+                host,
+                entries,
+                toolByName,
+                idToName: new Map(entries.map((entry) => [entry.id, entry.name]))
+            };
+            try {
+                register(entries, toolByName);
+            }
+            catch (cause) {
+                current = undefined;
+                deactivateOwned();
+                await host.dispose();
+                throw new CapabilityError('Pi tool registration failed.', 'UNAVAILABLE', { reason: 'pi-activation-failed', cause });
+            }
+            return current;
+        };
+        const register = (entries, toolByName) => {
+            const discoveryToolIds = new Set(PI_INITIAL_TOOL_IDS);
+            const registeredSession = current;
+            for (const entry of entries) {
+                const def = toolByName.get(entry.name);
+                if (!def)
+                    throw new CapabilityError('Pi tool projection is incomplete.', 'INTERNAL', { reason: 'pi-tool-projection-invalid' });
+                ownedNames.add(entry.name);
+                const isDiscovery = discoveryToolIds.has(entry.id);
+                pi.registerTool({
+                    name: entry.name,
+                    label: def.label,
+                    description: def.description,
+                    parameters: def.inputSchema,
+                    // The runtime's published output schema, when it has one, so the
+                    // model knows what a successful call answers before it makes one.
+                    outputSchema: def.outputSchema,
+                    exposure: isDiscovery ? 'direct' : 'codemode',
+                    defaultActive: isDiscovery,
+                    renderCall: (args, theme, context) => renderCall(def, args, theme, context),
+                    renderResult,
+                    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+                        const selected = sessionFor(ctx);
+                        if (selected.toolByName.get(entry.name) !== def)
+                            throw new CapabilityError('Vibes tool is unavailable in the current session', 'UNAVAILABLE', { reason: 'pi-stale-tool' });
+                        if (!selected.host.catalog().some(tool => tool.id === entry.id && tool.enabled !== false))
+                            throw new CapabilityError('The runtime no longer offers this tool.', 'UNAVAILABLE', { reason: 'pi-stale-tool' });
+                        const executionGeneration = generation;
+                        const input = params ?? {};
+                        if (sessionFor(ctx) !== selected)
+                            throw new CapabilityError('Pi workspace changed before invocation.', 'UNAVAILABLE', { reason: 'pi-stale-tool' });
+                        onUpdate?.({ content: [{ type: 'text', text: 'Running in the Vibes runtime…' }], details: { toolId: entry.id } });
+                        const startTime = performance.now();
+                        const output = await selected.host.invokeTool(entry.id, hostToolInput(input), { ...harnessOf(ctx), signal });
+                        const durationMs = Math.round(performance.now() - startTime);
+                        const resultText = toolText(output);
+                        if (entry.id === 'tool-search' && generation === executionGeneration && current === selected) {
+                            activatePiSearchHits(pi, resultText, selected.idToName);
+                        }
+                        const outputText = PiStringSchema.safeParse(output);
+                        const structured = outputText.success ? parseOutput(outputText.data) : PiJsonSchema.optional().parse(output);
+                        return {
+                            content: [{ type: 'text', text: resultText }],
+                            details: {
+                                toolId: entry.id,
+                                exitCode: 0,
+                                durationMs,
+                                output: structured ?? null
+                            },
+                            structuredContent: structured
+                        };
+                    }
+                });
+            }
+            if (options.enableKernelTool) {
+                ownedNames.add('vibes');
+                pi.registerTool({
+                    name: 'vibes',
+                    label: 'Vibes Runtime Kernel',
+                    description: 'Query and invoke the Vibes runtime kernel directly. In codemode scripts, use `await tools.vibes({ op: "query", kind: "tools/tool" })` to inspect descriptors, or `await tools.vibes({ op: "invoke", id: "<tool-id>", params: {...} })` to execute tools.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            op: {
+                                type: 'string',
+                                enum: ['query', 'invoke', 'status', 'prompts'],
+                                description: 'The kernel operation: query descriptors, invoke a tool, get runtime status, or list prompt manifests'
+                            },
+                            kind: {
+                                type: 'string',
+                                description: 'For query: the kind of descriptors to query, e.g. "tools/tool", "code/rules", "paths/roots"'
+                            },
+                            id: {
+                                type: 'string',
+                                description: 'For invoke: the tool id to invoke'
+                            },
+                            params: {
+                                type: 'object',
+                                description: 'For invoke: parameters to pass to the invocation'
+                            }
+                        },
+                        required: ['op']
+                    },
+                    exposure: 'codemode',
+                    defaultActive: false,
+                    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+                        const selected = sessionFor(ctx);
+                        if (selected !== registeredSession)
+                            throw new CapabilityError('Pi kernel tool belongs to a replaced session.', 'UNAVAILABLE', { reason: 'pi-stale-tool' });
+                        const admitted = PiKernelInputSchema.safeParse(params);
+                        if (!admitted.success)
+                            throw new CapabilityError('Pi kernel input is invalid.', 'INVALID_INPUT', { reason: 'pi-kernel-input-invalid', cause: admitted.error });
+                        const kernel = admitted.data;
+                        const op = kernel.op;
+                        if (op === 'status') {
+                            const status = {
+                                workspace: selected.cwd,
+                                root: selected.host.root,
+                                phase: selected.host.runtime.phase,
+                                toolCount: selected.entries.length
+                            };
+                            return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }], details: { op: 'status' }, structuredContent: status };
+                        }
+                        if (op === 'prompts') {
+                            const manifests = selected.host.prompts().map((descriptor) => ({
+                                id: descriptor.id,
+                                name: descriptor.manifest.name,
+                                type: descriptor.manifest.type,
+                                description: descriptor.manifest.description ?? ''
+                            }));
+                            return { content: [{ type: 'text', text: JSON.stringify(manifests, null, 2) }], details: { op: 'prompts', count: manifests.length }, structuredContent: manifests };
+                        }
+                        if (op === 'query') {
+                            const kind = kernel.kind;
+                            if (!selected.host.runtime.hasKind(kind)) {
+                                const registered = selected.host.runtime.kindIds();
+                                const suggestions = registered.filter((id) => id.includes(kind.split('/').pop() ?? '')).slice(0, 8);
+                                throw new CapabilityError(`Unknown kind "${kind}". ${suggestions.length > 0 ? `Did you mean: ${suggestions.join(', ')}?` : `Registered kinds: ${registered.slice(0, 30).join(', ')}${registered.length > 30 ? ` … (${registered.length} total)` : ''}.`}`, 'NOT_FOUND', { reason: 'pi-kind-unavailable' });
+                            }
+                            const descriptors = selected.host.runtime.query(kind).descriptors();
+                            return { content: [{ type: 'text', text: JSON.stringify(descriptors, null, 2) }], details: { op: 'query', kind }, structuredContent: PiJsonSchema.parse(JSON.parse(JSON.stringify(descriptors))) };
+                        }
+                        if (op === 'invoke') {
+                            const toolId = kernel.id ?? '';
+                            if (!toolId)
+                                throw new CapabilityError('Missing tool id.', 'INVALID_INPUT', { reason: 'pi-tool-id-required' });
+                            if (!selected.idToName.has(toolId)) {
+                                // Not in this session's projected catalog — suggest close
+                                // matches, but do not block: the kernel can invoke any
+                                // registered tool, including ones the Pi projection
+                                // filtered or renamed.
+                                const known = [...selected.idToName.keys()];
+                                const suggestions = known.filter((id) => id.includes(toolId.split('/').pop() ?? '')).slice(0, 5);
+                                if (suggestions.length > 0 && suggestions[0] !== toolId) {
+                                    _onUpdate?.({ content: [{ type: 'text', text: `Did you mean: ${suggestions.join(', ')}?` }], details: { suggestions } });
+                                }
+                            }
+                            if (sessionFor(ctx) !== selected)
+                                throw new CapabilityError('Pi workspace changed before invocation.', 'UNAVAILABLE', { reason: 'pi-stale-tool' });
+                            const startTime = performance.now();
+                            const output = await selected.host.invokeTool(toolId, hostToolInput(kernel.params), { ...harnessOf(ctx), signal });
+                            const durationMs = Math.round(performance.now() - startTime);
+                            return {
+                                content: [{ type: 'text', text: toolText(output) }],
+                                details: { toolId, exitCode: 0, durationMs, output: output ?? null },
+                                structuredContent: output
+                            };
+                        }
+                        throw new Error(`Unsupported vibes kernel operation: "${op}". Expected "query", "invoke", or "status".`);
+                    }
+                });
+            }
+        };
+        // Slash commands are registered per session, from the `cli/command`
+        // descriptors that session's runtime holds. Pi has no way to unregister a
+        // command, so the set is registered once against the first session's
+        // runtime and every later session resolves the same names against its own.
+        let commandsRegistered = false;
+        const registerCommands = (host) => {
+            if (commandsRegistered)
+                return;
+            const specs = piCommandSpecs(host);
+            if (specs.length === 0)
+                return;
+            commandsRegistered = true;
+            for (const spec of specs) {
+                pi.registerCommand?.(spec.name, {
+                    description: spec.description,
+                    handler: async (rawArgs, ctx) => {
+                        await (activation ?? (await firstActivation).activation);
+                        const selected = sessionFor(ctx);
+                        const live = piCommandSpecs(selected.host).find(candidate => candidate.name === spec.name);
+                        if (!live)
+                            throw new CapabilityError('Pi command is unavailable in this workspace.', 'UNAVAILABLE', { reason: 'pi-stale-command' });
+                        await runVibesPiCommand(selected.host, live, ctx.ui, rawArgs ?? '');
+                    }
+                });
+            }
+        };
+        const reportFailure = (stage, cause, host) => {
+            const failure = valueFreeFailure(CaughtFailureSchema.parse(cause));
+            if (current)
+                getLogger('integrations-pi', current.host.runtime).warn(stage, { failure });
+            host.ui?.notify?.(stage + ': ' + (failure.reason ?? failure.code ?? failure.name), 'error');
+            host.ui?.setStatus?.('vibes', 'vibes · session unavailable');
+        };
+        pi.on('session_start', async (_event, ctx) => {
+            const host = PiHostContextSchema.parse(ctx);
+            const cwd = host.cwd ?? options.workspaceRoot;
+            if (current?.cwd === cwd && activation)
+                return;
+            activation = activate(cwd, options.catalog ?? undefined).then(selected => completeActivation(selected, host));
+            announceActivation({ activation });
+            const ownedActivation = activation;
+            void settle(() => ownedActivation).then(result => {
+                if (!result.ok)
+                    reportFailure('Pi activation failed', result.cause, host);
+            });
+        });
+        const onActivationLanded = async (selected, host) => {
+            if (!selected || current !== selected)
+                return;
+            applyVibesPiChrome(host.ui);
+            // Runtime events → host notifications: signal updates, check
+            // completions, git state changes surface as one-line notices
+            // without the agent polling for them.
+            stopEventForwarding = forwardRuntimeEvents(selected.host.runtime, host.ui?.notify?.bind(host.ui));
+            restrictPiToolsToDiscovery(pi, current.entries);
+            registerCommands(selected.host);
+            await bindSession(selected, host);
+            if (current !== selected || disposed)
+                return;
+            const unproject = await projectVirtualModels(pi, selected.host);
+            if (current === selected && !disposed)
+                unprojectModels = unproject;
+            else
+                unproject();
+        };
+        const completeActivation = async (selected, host) => {
+            const landed = await settle(() => onActivationLanded(selected, host));
+            if (landed.ok)
+                return selected;
+            let cause = landed.cause;
+            if (selected && current === selected) {
+                current = undefined;
+                deactivateOwned();
+                const retired = await settle(() => selected.host.dispose());
+                if (!retired.ok)
+                    cause = new AggregateError([landed.cause, retired.cause], 'Pi activation and cleanup failed', { cause: landed.cause });
+            }
+            throw new CapabilityError('Pi projection activation failed.', 'UNAVAILABLE', { reason: 'pi-activation-failed', cause });
+        };
+        pi.on('session_shutdown', async () => {
+            disposed = true;
+            announceActivation({ activation: Promise.resolve(undefined) });
+            generation++;
+            const previous = current;
+            current = undefined;
+            deactivateOwned();
+            const previousPending = pendingHost;
+            pendingHost = undefined;
+            await previous?.host.dispose();
+            if (previousPending) {
+                const pending = await settle(() => previousPending);
+                if (pending.ok)
+                    await pending.value.dispose();
+                else
+                    reportFailure('Previous Pi boot failed', pending.cause, {});
+            }
+            if (activation) {
+                const stopped = await settle(() => activation);
+                if (!stopped.ok)
+                    reportFailure('Pi activation ended during shutdown', stopped.cause, {});
+            }
+        });
+        pi.on('tool_call', async (event, ctx) => {
+            if (posture === 'off')
+                return;
+            const parsedEvent = PiToolCallEventSchema.parse(event);
+            if (!current && !disposed && ownedNames.has(parsedEvent.toolName)) {
+                await (activation ?? (await firstActivation).activation);
+            }
+            if (!current && !ownedNames.has(parsedEvent.toolName))
+                return;
+            const host = PiHostContextSchema.parse(ctx);
+            const selected = sessionFor(host);
+            const root = selected.cwd;
+            const cwd = selected.cwd;
+            const memory = options.approvalMemory ?? await getPiApprovalMemory(selected.host.runtime);
+            if (memory.runtime !== selected.host.runtime)
+                throw new CapabilityError('Pi approval memory belongs to another runtime.', 'CONFLICT', { reason: 'pi-workspace-mismatch' });
+            return await confirmMutatingTool(parsedEvent, host.ui, { memory, cwd, workspaceRoot: root, posture, host: selected.host });
+        });
+        if (injectSystemPrompt) {
+            pi.on('before_agent_start', async (input, ctx) => {
+                const event = PiExtensionEventSchema.parse(input);
+                // The first prompt can arrive while the session_start activation is
+                // still booting the runtime; the briefing names what that activation
+                // registered, so it waits for the same landing slash commands do.
+                await (activation ?? (await firstActivation).activation);
+                const selected = sessionFor(PiHostContextSchema.parse(ctx));
+                const { entries, toolByName } = selected;
+                const promptCatalog = entries.filter((entry) => new Set(PI_INITIAL_TOOL_IDS).has(entry.id));
+                const promptEntries = (promptCatalog.length > 0 ? promptCatalog : entries).map((entry) => ({
+                    id: entry.id,
+                    name: entry.name,
+                    summary: toolByName.get(entry.name)?.description
+                }));
+                const text = event.systemPrompt ?? '';
+                if (text.includes('System prompt provenance:'))
+                    return { systemPrompt: text };
+                // The session's agent identity first (the runtime's prompt
+                // manifests), then the tool briefing over what actually registered.
+                const rolePrompt = renderAgentRolePrompt(selected.host, options.promptManifestIds);
+                const briefing = buildLivePiHarnessPrompt(promptEntries, { root: selected.cwd });
+                const prompt = rolePrompt ? `${rolePrompt}\n\n${briefing}` : briefing;
+                return {
+                    systemPrompt: event.systemPromptOptions?.customPrompt ? prompt + '\n\n' + text : prompt
+                };
+            });
+        }
+        // Explicit catalogs preserve the public embedded factory's eager validation;
+        // with a workspace in hand the runtime boots now too. Native discovery waits
+        // for session_start, where Pi supplies the workspace.
+        if (options.catalog != null) {
+            assertEntries(options.catalog.map((descriptor) => normalizeLiveTool(descriptor)), reserved);
+            if (options.workspaceRoot) {
+                // The eager boot is this extension's first activation: every waiter
+                // (a prompt racing the boot, an early command) settles on it.
+                activation = activate(options.workspaceRoot, options.catalog).then(selected => completeActivation(selected, {}));
+                announceActivation({ activation });
+                await activation;
+            }
+        }
+        return {
+            /** Joins the current activation without blocking the native session_start callback. */
+            whenReady: async () => { await (activation ?? (await firstActivation).activation); }
+        };
+    };
+}
+function assertEntries(tools, reserved) {
+    return assertPiToolCatalog(tools, reserved);
+}
+/**
+ * settings.json projection for a tool policy. `defaultTools` is omitted for
+ * `native`, which leaves the host default untouched; Pi keeps extension tools
+ * either way.
+ */
+export function piSettingsForProfile(profile = DEFAULT_PI_TOOL_POLICY_PROFILE, extensionRef = './extensions/vibes.ts') {
+    const settings = PiSettingsSchema.parse({ extensions: [extensionRef] });
+    const defaultTools = piDefaultToolsForProfile(profile, PI_BUILTIN_TOOLS);
+    if (defaultTools !== undefined)
+        settings.defaultTools = defaultTools;
+    return settings;
+}
+/** Default projection used by the installer: builtins off, extension loaded. */
+export const VIBES_PI_SETTINGS = piSettingsForProfile('isolated');
+/**
+ * Default factory Pi loads from `.pi/extensions/vibes.ts`. This module is the
+ * host entry inside the Pi process, so it hands in Pi's own environment.
+ */
+export { default } from "./entry.js";
+//# sourceMappingURL=index.js.map