@llblab/pi-kit 0.1.0

package/node_modules/@llblab/pi-actors/dist/lib/extension-runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as Pi from "./pi.ts";
+import * as RecipesReferences from "./recipes-references.ts";
+export interface ActorExtensionRuntime {
+    beforeAgentStart(systemPrompt: string, skills: RecipesReferences.ActiveSkillRecipeSource[], ctx: Pi.ExtensionContext): {
+        systemPrompt: string;
+    };
+    discoverResources(metaUrl: string): {
+        skillPaths: string[];
+    } | undefined;
+    getRunOwnerId(ctx: Pi.ExtensionContext): string;
+    onAgentEnd(ctx: Pi.ExtensionContext): void;
+    onSessionShutdown(reason: string, ctx: Pi.ExtensionContext): void;
+    onSessionStart(ctx: Pi.ExtensionContext): Promise<void>;
+    registerCoreTools(): void;
+}
+export declare function createActorExtensionRuntime(pi: Pi.ExtensionAPI): ActorExtensionRuntime;

package/node_modules/@llblab/pi-actors/dist/lib/extension-runtime.js

@@ -0,0 +1,141 @@
+/**
+ * Pi actor extension runtime coordinator.
+ * Zones: extension session lifecycle, host tool adaptation, runtime service composition
+ * Owns low-level Pi lifecycle effects and tool wrapping without owning event registration.
+ */
+import * as AutomaticReviewRuntime from "./automatic-review-runtime.js";
+import * as CommandTemplates from "./command-templates.js";
+import * as Paths from "./paths.js";
+import * as Pi from "./pi.js";
+import * as Prompts from "./prompts.js";
+import * as RecipeResolution from "./recipes-context.js";
+import * as RecipesReferences from "./recipes-references.js";
+import * as RunUiRuntime from "./run-ui-runtime.js";
+import * as Runtime from "./runtime.js";
+import * as Temp from "./temp.js";
+import * as Tools from "./tools.js";
+import * as ToolsResponse from "./tools-response.js";
+export function createActorExtensionRuntime(pi) {
+    let activeRunContext;
+    const recipeResolutionContextsBySession = new Map();
+    const getRunOwnerId = Pi.getSessionId;
+    const getRecipeResolutionContext = (ctx) => {
+        const sessionId = getRunOwnerId(ctx);
+        const resolutionContext = recipeResolutionContextsBySession.get(sessionId);
+        if (!resolutionContext) {
+            throw new Error(`Recipe resolution context is unavailable for session ${sessionId}.`);
+        }
+        return resolutionContext;
+    };
+    const automaticReview = AutomaticReviewRuntime.createAutomaticReviewRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        getThinkingLevel: () => pi.getThinkingLevel(),
+    });
+    const runUiRuntime = RunUiRuntime.createRunUiRuntime({
+        getActiveContext: () => activeRunContext,
+        getRunOwnerId,
+        onRunEvent: automaticReview.schedule,
+        pi,
+    });
+    const actorToolDefinitions = new Map();
+    const withCurrentThinkingContext = (definition) => {
+        if (typeof definition.execute !== "function")
+            return definition;
+        const execute = definition.execute;
+        return {
+            ...definition,
+            execute: async (...args) => {
+                const nextArgs = [...args];
+                const ctx = nextArgs[4];
+                if (ctx && typeof ctx === "object") {
+                    nextArgs[4] = {
+                        ...ctx,
+                        recipeResolutionContext: getRecipeResolutionContext(ctx),
+                        getThinkingLevel: () => pi.getThinkingLevel(),
+                    };
+                }
+                try {
+                    return ToolsResponse.spaceToolResult(await execute(...nextArgs));
+                }
+                catch (error) {
+                    throw ToolsResponse.spaceToolError(error);
+                }
+            },
+        };
+    };
+    const runtime = Runtime.createAutoToolsRuntime({
+        configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+        exec: CommandTemplates.execCommandTemplate,
+        getActiveTools: () => pi.getActiveTools(),
+        getAllTools: () => pi.getAllTools(),
+        registerTool: (definition) => {
+            const wrapped = withCurrentThinkingContext(definition);
+            actorToolDefinitions.set(wrapped.name, wrapped);
+            pi.registerTool(wrapped);
+        },
+        reservedToolNames: Tools.RESERVED_TOOL_NAMES,
+        setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+    });
+    const recipeReload = Runtime.createRecipeToolReloadWatcher(runtime, {
+        getResolutionContext: () => activeRunContext
+            ? getRecipeResolutionContext(activeRunContext)
+            : undefined,
+    });
+    return {
+        beforeAgentStart(systemPrompt, skills, ctx) {
+            const sessionId = getRunOwnerId(ctx);
+            const resolutionContext = RecipeResolution.createRecipeResolutionContext(sessionId, ctx.cwd, RecipesReferences.createActiveSkillRecipeContext(skills));
+            recipeResolutionContextsBySession.set(sessionId, resolutionContext);
+            runtime.loadTools(ctx, resolutionContext);
+            return {
+                systemPrompt: `${systemPrompt}\n\n${Prompts.ONBOARDING_SYSTEM_PROMPT}`,
+            };
+        },
+        discoverResources(metaUrl) {
+            const skillPaths = Paths.getExistingExtensionSkillPaths(metaUrl);
+            return skillPaths.length > 0 ? { skillPaths } : undefined;
+        },
+        getRunOwnerId,
+        onAgentEnd(ctx) {
+            if (activeRunContext === ctx)
+                automaticReview.schedule();
+        },
+        onSessionShutdown(reason, ctx) {
+            recipeResolutionContextsBySession.delete(getRunOwnerId(ctx));
+            activeRunContext = undefined;
+            automaticReview.close();
+            recipeReload.close();
+            runUiRuntime.shutdown(reason, ctx);
+        },
+        async onSessionStart(ctx) {
+            const sessionId = getRunOwnerId(ctx);
+            recipeResolutionContextsBySession.set(sessionId, RecipeResolution.createEmptyRecipeResolutionContext(sessionId, ctx.cwd));
+            ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+            activeRunContext = ctx;
+            runUiRuntime.close();
+            automaticReview.close();
+            recipeReload.close();
+            await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
+            if (activeRunContext !== ctx)
+                return;
+            automaticReview.start(ctx);
+            runUiRuntime.start(ctx);
+            recipeReload.watch(ctx);
+        },
+        registerCoreTools() {
+            Pi.registerToolDefinitions(pi, Tools.createCoreActorToolDefinitions({
+                configPath: Paths.EXTENSION_RUNTIME_PATHS.configPath,
+                getActiveTools: () => pi.getActiveTools(),
+                getRecipeResolutionContext: () => activeRunContext
+                    ? getRecipeResolutionContext(activeRunContext)
+                    : undefined,
+                getRuntimeTool: (name) => Tools.resolveActiveRuntimeTool(name, runtime.getTools(), (activeName) => actorToolDefinitions.get(activeName)),
+                getRuntimeToolStatus: runtime.getToolStatus,
+                handleRuntimeControl: automaticReview.handleControl,
+                registryRuntime: runtime,
+                setActiveTools: (toolNames) => pi.setActiveTools(toolNames),
+            }).map(withCurrentThinkingContext));
+        },
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/file-state.d.ts

@@ -0,0 +1,18 @@
+/**
+ * File state persistence helpers
+ * Zones: file persistence, atomic writes, runtime state support
+ * Owns generic durable JSON file writes shared by registry config and async run state.
+ */
+export declare function mutationLockPath(path: string): string;
+export interface FileMutationLockOptions {
+    onBeforeLockPublish?(): void;
+    onBeforeReclaimRemove?(): void;
+    onContention?(): void;
+    onRemovalContention?(): void;
+}
+export declare function acquireFileMutationLock(path: string, options?: FileMutationLockOptions): () => void;
+export declare function withFileMutationLock<T>(path: string, mutate: () => T, options?: FileMutationLockOptions): T;
+export declare function writeTextAtomic(path: string, content: string, options?: {
+    onBeforeReplace?(): void;
+}): void;
+export declare function writeJsonAtomic(path: string, value: unknown): void;

package/node_modules/@llblab/pi-actors/dist/lib/file-state.js

@@ -0,0 +1,310 @@
+/**
+ * File state persistence helpers
+ * Zones: file persistence, atomic writes, runtime state support
+ * Owns generic durable JSON file writes shared by registry config and async run state.
+ */
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, parse, resolve } from "node:path";
+const FILE_MUTATION_LOCK_TIMEOUT_MS = process.platform === "win32" ? 30000 : 15000;
+const FILE_MUTATION_LOCK_STALE_MS = 30000;
+const FILE_MUTATION_LOCK_RECLAIM_POLL_MS = 100;
+const FILE_MUTATION_LOCK_REMOVAL_GRACE_MS = 250;
+const FILE_MUTATION_LOCK_MAX_WAIT_MS = 50;
+const FILE_MUTATION_LOCK_ROOT = join(tmpdir(), "pi-actors-file-locks");
+function canonicalMutationPath(path) {
+    const absolute = resolve(path);
+    try {
+        if (lstatSync(absolute).isSymbolicLink()) {
+            const target = realpathSync.native(absolute);
+            return process.platform === "win32" ? target.toLowerCase() : target;
+        }
+    }
+    catch {
+        /* Materialization may race lock-key derivation; canonicalize through the parent. */
+    }
+    const suffix = [basename(absolute)];
+    let existing = dirname(absolute);
+    while (!existsSync(existing)) {
+        const parent = dirname(existing);
+        if (parent === existing || existing === parse(existing).root)
+            break;
+        suffix.unshift(basename(existing));
+        existing = parent;
+    }
+    const canonicalAncestor = existsSync(existing)
+        ? realpathSync.native(existing)
+        : existing;
+    const canonical = resolve(canonicalAncestor, ...suffix);
+    return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+}
+export function mutationLockPath(path) {
+    const key = createHash("sha256")
+        .update(canonicalMutationPath(path))
+        .digest("hex");
+    return join(FILE_MUTATION_LOCK_ROOT, `${key}.lock`);
+}
+function isZombieProcess(pid) {
+    if (process.platform === "linux")
+        try {
+            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+            return stat.slice(stat.lastIndexOf(")") + 2).startsWith("Z ");
+        }
+        catch {
+            return false;
+        }
+    if (process.platform !== "darwin")
+        return false;
+    const result = spawnSync("ps", ["-p", String(pid), "-o", "stat="], { encoding: "utf8" });
+    return result.status === 0 && result.stdout.trim().startsWith("Z");
+}
+function lockOwnerStatus(lockPath) {
+    try {
+        const owner = JSON.parse(readFileSync(join(lockPath, "owner.json"), "utf8"));
+        const pid = Number(owner.pid);
+        if (!Number.isInteger(pid) || pid <= 0)
+            return "unknown";
+        try {
+            process.kill(pid, 0);
+            if (Date.now() - statSync(lockPath).mtimeMs > FILE_MUTATION_LOCK_REMOVAL_GRACE_MS &&
+                isZombieProcess(pid))
+                return "dead";
+            return "alive";
+        }
+        catch (error) {
+            return error.code === "ESRCH"
+                ? "dead"
+                : "unknown";
+        }
+    }
+    catch {
+        return "unknown";
+    }
+}
+function readLockToken(lockPath) {
+    try {
+        const owner = JSON.parse(readFileSync(join(lockPath, "owner.json"), "utf8"));
+        return typeof owner.token === "string" ? owner.token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function prepareLockBoundary(lockPath, token, onBeforePublish) {
+    const pendingPath = `${lockPath}.${process.pid}.${token}.pending`;
+    try {
+        mkdirSync(pendingPath);
+        writeFileSync(join(pendingPath, "owner.json"), `${JSON.stringify({ pid: process.pid, token, acquired_at: new Date().toISOString() })}\n`, "utf8");
+        onBeforePublish?.();
+        return pendingPath;
+    }
+    catch (error) {
+        try {
+            rmSync(pendingPath, { recursive: true, force: true });
+        }
+        catch { }
+        throw error;
+    }
+}
+function removeLockBoundary(lockPath, token) {
+    if (readLockToken(lockPath) !== token)
+        return false;
+    if (process.platform === "win32")
+        try {
+            rmSync(lockPath, { recursive: true, force: true, maxRetries: 20, retryDelay: 5 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    const removingPath = `${lockPath}.${process.pid}.${randomUUID()}.removing`;
+    try {
+        renameSync(lockPath, removingPath);
+    }
+    catch {
+        return false;
+    }
+    try {
+        rmSync(removingPath, { recursive: true, force: true });
+    }
+    catch { }
+    return true;
+}
+function tryReclaimRemovalBoundary(reclaimPath) {
+    if (!existsSync(reclaimPath))
+        return;
+    try {
+        const age = Date.now() - statSync(reclaimPath).mtimeMs;
+        if (age <= FILE_MUTATION_LOCK_REMOVAL_GRACE_MS)
+            return;
+        const inspectedToken = readLockToken(reclaimPath);
+        const ownerStatus = lockOwnerStatus(reclaimPath);
+        if ((ownerStatus === "dead" ||
+            (ownerStatus === "unknown" && age > FILE_MUTATION_LOCK_STALE_MS)) &&
+            readLockToken(reclaimPath) === inspectedToken) {
+            removeLockBoundary(reclaimPath, inspectedToken);
+        }
+    }
+    catch {
+        /* another contender changed the boundary */
+    }
+}
+function withRemovalBoundary(lockPath, action) {
+    const reclaimPath = `${lockPath}.reclaim`;
+    const token = randomUUID();
+    const pendingPath = prepareLockBoundary(reclaimPath, token);
+    try {
+        try {
+            renameSync(pendingPath, reclaimPath);
+        }
+        catch {
+            tryReclaimRemovalBoundary(reclaimPath);
+            return false;
+        }
+        try {
+            action();
+            return true;
+        }
+        finally {
+            removeLockBoundary(reclaimPath, token);
+        }
+    }
+    finally {
+        try {
+            rmSync(pendingPath, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+function tryReclaimMutationLock(lockPath, options) {
+    let reclaimed = false;
+    if (!withRemovalBoundary(lockPath, () => {
+        if (!existsSync(lockPath)) {
+            reclaimed = true;
+            return;
+        }
+        const inspectedToken = readLockToken(lockPath);
+        const age = Date.now() - statSync(lockPath).mtimeMs;
+        const ownerStatus = lockOwnerStatus(lockPath);
+        if ((ownerStatus === "dead" ||
+            (ownerStatus === "unknown" && age > FILE_MUTATION_LOCK_STALE_MS)) &&
+            readLockToken(lockPath) === inspectedToken) {
+            options.onBeforeReclaimRemove?.();
+            reclaimed = removeLockBoundary(lockPath, inspectedToken);
+        }
+    })) {
+        return false;
+    }
+    return reclaimed;
+}
+export function acquireFileMutationLock(path, options = {}) {
+    mkdirSync(FILE_MUTATION_LOCK_ROOT, { recursive: true });
+    const lockPath = mutationLockPath(path);
+    const deadline = Date.now() + FILE_MUTATION_LOCK_TIMEOUT_MS;
+    const token = randomUUID();
+    const pendingPath = prepareLockBoundary(lockPath, token, options.onBeforeLockPublish);
+    let contentionReported = false;
+    let nextReclaimAt = 0;
+    let waitMs = 10;
+    try {
+        for (;;) {
+            try {
+                renameSync(pendingPath, lockPath);
+                break;
+            }
+            catch (error) {
+                if (!contentionReported) {
+                    contentionReported = true;
+                    options.onContention?.();
+                }
+                const now = Date.now();
+                if (now >= nextReclaimAt) {
+                    nextReclaimAt = now + FILE_MUTATION_LOCK_RECLAIM_POLL_MS;
+                    if (tryReclaimMutationLock(lockPath, options)) {
+                        waitMs = 10;
+                        continue;
+                    }
+                }
+                if (now >= deadline) {
+                    throw new Error(`Timed out waiting for file mutation lock: ${canonicalMutationPath(path)}`, {
+                        cause: error,
+                    });
+                }
+                const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(waitMs / 2)));
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs + jitter);
+                waitMs = Math.min(FILE_MUTATION_LOCK_MAX_WAIT_MS, waitMs + 5);
+            }
+        }
+    }
+    finally {
+        try {
+            rmSync(pendingPath, { recursive: true, force: true });
+        }
+        catch { }
+    }
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const deadline = Date.now() + FILE_MUTATION_LOCK_TIMEOUT_MS;
+        let removalContentionReported = false;
+        while (!withRemovalBoundary(lockPath, () => {
+            removeLockBoundary(lockPath, token);
+        })) {
+            if (!removalContentionReported) {
+                removalContentionReported = true;
+                options.onRemovalContention?.();
+            }
+            if (Date.now() >= deadline)
+                return;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    };
+}
+export function withFileMutationLock(path, mutate, options = {}) {
+    const release = acquireFileMutationLock(path, options);
+    try {
+        return mutate();
+    }
+    finally {
+        release();
+    }
+}
+function replaceFileWithRetry(source, target) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            renameSync(source, target);
+            return;
+        }
+        catch (error) {
+            const code = error.code;
+            if ((code !== "EPERM" && code !== "EBUSY") || attempt >= 19)
+                throw error;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+        }
+    }
+}
+export function writeTextAtomic(path, content, options = {}) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(tempPath, content, "utf8");
+        options.onBeforeReplace?.();
+        replaceFileWithRetry(tempPath, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch {
+            /* best effort */
+        }
+        throw error;
+    }
+}
+export function writeJsonAtomic(path, value) {
+    writeTextAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}

package/node_modules/@llblab/pi-actors/dist/lib/identity.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Identifier normalization helpers
+ * Zones: registry identity, shared validation
+ * Owns stable tool, argument, and file-label identifier normalization
+ */
+export declare function normalizeIdentifier(value: string, prefix: string): string;
+export declare function normalizeToolName(value: string): string;
+export declare function normalizeArgName(value: string): string;
+export declare function sanitizeFilePart(value: string): string;

package/node_modules/@llblab/pi-actors/dist/lib/identity.js

@@ -0,0 +1,27 @@
+/**
+ * Identifier normalization helpers
+ * Zones: registry identity, shared validation
+ * Owns stable tool, argument, and file-label identifier normalization
+ */
+export function normalizeIdentifier(value, prefix) {
+    let name = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    if (!name)
+        return "";
+    if (/^[0-9]/.test(name))
+        name = `${prefix}_${name}`;
+    return name.slice(0, 64).replace(/_+$/g, "");
+}
+export function normalizeToolName(value) {
+    return normalizeIdentifier(value, "tool");
+}
+export function normalizeArgName(value) {
+    return normalizeIdentifier(value, "arg");
+}
+export function sanitizeFilePart(value) {
+    return normalizeIdentifier(value, "tool") || "tool";
+}

package/node_modules/@llblab/pi-actors/dist/lib/inspector-actions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Actor Inspector actions for concrete Run instances.
+ * Owns: exact-session run-action authorization, canonical kill routing, and bounded operator feedback.
+ */
+export interface ActorInspectorKillResult {
+    ok: boolean;
+    message: string;
+}
+export interface ActorInspectorKillDeps {
+    getRunStatus: (runOrDir: string) => Record<string, unknown>;
+    killRun: (runOrDir: string, expected: {
+        ownerId: string;
+        runInstanceId: string;
+    }) => Record<string, unknown>;
+}
+export declare function killOwnedRunFromInspector(ownerId: string, run: string, stateRoot: string, expectedRunInstanceId: string, deps: ActorInspectorKillDeps): ActorInspectorKillResult;

package/node_modules/@llblab/pi-actors/dist/lib/inspector-actions.js

@@ -0,0 +1,57 @@
+/**
+ * Actor Inspector actions for concrete Run instances.
+ * Owns: exact-session run-action authorization, canonical kill routing, and bounded operator feedback.
+ */
+import { join } from "node:path";
+import { safeRunId } from "./runs-identity.js";
+const FEEDBACK_LIMIT = 180;
+function bounded(value) {
+    const text = String(value ?? "").replaceAll(/\s+/g, " ").trim();
+    return text.length <= FEEDBACK_LIMIT
+        ? text
+        : `${text.slice(0, FEEDBACK_LIMIT - 1)}…`;
+}
+export function killOwnedRunFromInspector(ownerId, run, stateRoot, expectedRunInstanceId, deps) {
+    let stateDir;
+    try {
+        stateDir = join(stateRoot, safeRunId(run));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: `Kill rejected: ${bounded(error instanceof Error ? error.message : error)}`,
+        };
+    }
+    try {
+        const status = deps.getRunStatus(stateDir);
+        if (status.ownerId !== ownerId) {
+            return { ok: false, message: "Kill rejected: run ownership changed." };
+        }
+        if (status.status !== "running") {
+            return {
+                ok: false,
+                message: `Kill unavailable: run is ${bounded(status.status || "terminal")}.`,
+            };
+        }
+        if (status.run_instance_id !== expectedRunInstanceId) {
+            return { ok: false, message: "Kill rejected: run generation changed." };
+        }
+        const result = deps.killRun(stateDir, {
+            ownerId,
+            runInstanceId: expectedRunInstanceId,
+        });
+        if (result.killed === true) {
+            return { ok: true, message: `Killed run:${run}.` };
+        }
+        return {
+            ok: false,
+            message: `Kill failed: ${bounded(result.reason || "control rejected")}.`,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: `Kill failed: ${bounded(error instanceof Error ? error.message : error)}.`,
+        };
+    }
+}

package/node_modules/@llblab/pi-actors/dist/lib/inspector-command.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Actor Inspector command adapter.
+ * Zones: Pi command registration, overlay construction, owned-run control ports
+ * Owns host-facing Inspector launch wiring without owning Inspector state or actions.
+ */
+import type * as Pi from "./pi.ts";
+export declare function registerActorInspectorCommand(pi: Pi.ExtensionAPI, getRunOwnerId: (ctx: Pi.ExtensionContext) => string): void;

package/node_modules/@llblab/pi-actors/dist/lib/inspector-command.js

@@ -0,0 +1,37 @@
+/**
+ * Actor Inspector command adapter.
+ * Zones: Pi command registration, overlay construction, owned-run control ports
+ * Owns host-facing Inspector launch wiring without owning Inspector state or actions.
+ */
+import * as AsyncRuns from "./async-runs.js";
+import * as InspectorActions from "./inspector-actions.js";
+import * as InspectorOverlay from "./inspector-overlay.js";
+import * as Paths from "./paths.js";
+export function registerActorInspectorCommand(pi, getRunOwnerId) {
+    pi.registerCommand("actor-inspector", {
+        description: "Open the keyboard-driven Actor Inspector",
+        handler: async (_args, ctx) => {
+            ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+            await ctx.ui.custom((tui, theme, _keybindings, done) => new InspectorOverlay.ActorInspectorOverlay({
+                done,
+                killRun: (run, runInstanceId) => InspectorActions.killOwnedRunFromInspector(getRunOwnerId(ctx), run, Paths.EXTENSION_RUNTIME_PATHS.runStateRoot, runInstanceId, {
+                    getRunStatus: AsyncRuns.getRunStatus,
+                    killRun: AsyncRuns.killRun,
+                }),
+                ownerId: getRunOwnerId(ctx),
+                stateRoot: Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
+                theme,
+                tui,
+            }), {
+                overlay: true,
+                overlayOptions: {
+                    anchor: "center",
+                    width: "94%",
+                    minWidth: 72,
+                    maxHeight: "94%",
+                    margin: 1,
+                },
+            });
+        },
+    });
+}