@pasko70/pibo 1.9.7 → 1.9.9

package/dist/core/context-build.js

@@ -1,711 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { createDefaultPiboProfile } from "../plugins/builtin.js";
-import { getMcpAgentContextFile } from "../mcp/agent-context.js";
-import { getInstalledCliToolContextFile } from "../tools/registry.js";
-import { WEB_SEARCH_PROMPT_CONTRIBUTION, isWebSearchProviderTool, normalizeOpenAiWebSearchConfig, } from "../tools/web-search.js";
-import { buildPiboAvailableTools, buildPiboGuidelines, hasPiboSystemPromptTemplateMarkers, } from "./system-prompt-template.js";
-import { buildCodexCompatSystemPrompt } from "./codex-compat.js";
-import { readPiboBasePrompt } from "./base-prompt.js";
-import { DEFAULT_BUILTIN_TOOL_NAMES, InitialSessionContext } from "./profiles.js";
-import { createPiboRuntime } from "./runtime.js";
-import { getDefaultPiboWorkspace } from "./workspace.js";
-const SECRET_KEY_RE = /(api[_-]?key|authorization|bearer|cookie|credential|oauth|password|secret|token)/i;
-const SECRET_TEXT_PATTERNS = [
-    /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi,
-    /\b(sk|pk|rk)-[A-Za-z0-9_-]{16,}\b/g,
-    /\b(api[_-]?key|authorization|cookie|password|secret|token)\b\s*[:=]\s*[^\s\n,;]+/gi,
-];
-function byteLength(text) {
-    return Buffer.byteLength(text, "utf-8");
-}
-function estimateTokens(text) {
-    if (text.length === 0)
-        return 0;
-    return Math.ceil(text.length / 4);
-}
-function jsonText(value) {
-    return JSON.stringify(value, null, 2);
-}
-function estimateDirectNodeTokens(node) {
-    let tokens = 0;
-    if (node.hydratedText)
-        tokens += estimateTokens(node.hydratedText);
-    if (node.schemaJson !== undefined)
-        tokens += estimateTokens(jsonText(node.schemaJson));
-    if (node.payloadJson !== undefined)
-        tokens += estimateTokens(jsonText(node.payloadJson));
-    if (node.notes?.length)
-        tokens += estimateTokens(node.notes.join("\n"));
-    return tokens;
-}
-function applyTokenEstimates(node) {
-    const estimatedTokens = estimateDirectNodeTokens(node);
-    const estimatedChildrenTokens = (node.children ?? []).reduce((total, child) => total + (child.estimatedSubtreeTokens ?? child.estimatedTokens ?? 0), 0);
-    const estimatedSubtreeTokens = estimatedTokens + estimatedChildrenTokens;
-    if (estimatedTokens > 0)
-        node.estimatedTokens = estimatedTokens;
-    if (estimatedSubtreeTokens > 0)
-        node.estimatedSubtreeTokens = estimatedSubtreeTokens;
-    return node;
-}
-function redactText(text) {
-    let value = text;
-    for (const pattern of SECRET_TEXT_PATTERNS) {
-        value = value.replace(pattern, (match) => {
-            const separator = match.match(/[:=]/)?.[0];
-            if (!separator)
-                return "[REDACTED]";
-            return `${match.slice(0, match.indexOf(separator) + 1)} [REDACTED]`;
-        });
-    }
-    return { value, redacted: value !== text };
-}
-function redactJson(value) {
-    if (value === null || value === undefined)
-        return { value, redacted: false };
-    if (typeof value === "string")
-        return redactText(value);
-    if (typeof value === "number" || typeof value === "boolean")
-        return { value, redacted: false };
-    if (Array.isArray(value)) {
-        let redacted = false;
-        const next = value.map((item) => {
-            const result = redactJson(item);
-            redacted ||= result.redacted;
-            return result.value;
-        });
-        return { value: next, redacted };
-    }
-    if (typeof value === "object") {
-        let redacted = false;
-        const output = {};
-        for (const [key, item] of Object.entries(value)) {
-            if (SECRET_KEY_RE.test(key)) {
-                output[key] = "[REDACTED]";
-                redacted = true;
-                continue;
-            }
-            const result = redactJson(item);
-            redacted ||= result.redacted;
-            output[key] = result.value;
-        }
-        return { value: output, redacted };
-    }
-    return { value: String(value), redacted: false };
-}
-function sanitizeNode(input, parentId, order = 0) {
-    let redacted = input.redacted === true;
-    const { children, ...nodeInput } = input;
-    const node = {
-        ...nodeInput,
-        ...(parentId ? { parentId } : {}),
-        order,
-    };
-    if (node.hydratedText !== undefined) {
-        const result = redactText(node.hydratedText);
-        node.hydratedText = result.value;
-        redacted ||= result.redacted;
-        node.bytes = node.bytes ?? byteLength(node.hydratedText);
-    }
-    if (node.schemaJson !== undefined) {
-        const result = redactJson(node.schemaJson);
-        node.schemaJson = result.value;
-        redacted ||= result.redacted;
-    }
-    if (node.payloadJson !== undefined) {
-        const result = redactJson(node.payloadJson);
-        node.payloadJson = result.value;
-        redacted ||= result.redacted;
-    }
-    if (node.metadata !== undefined) {
-        const result = redactJson(node.metadata);
-        node.metadata = result.value;
-        redacted ||= result.redacted;
-    }
-    if (node.notes !== undefined) {
-        const redactedNotes = node.notes.map((note) => redactText(note));
-        node.notes = redactedNotes.map((note) => note.value);
-        redacted ||= redactedNotes.some((note) => note.redacted);
-    }
-    if (children?.length) {
-        node.children = children.map((child, childIndex) => sanitizeNode(child, input.id, childIndex));
-    }
-    if (redacted)
-        node.redacted = true;
-    return applyTokenEstimates(node);
-}
-function countNodes(nodes) {
-    return nodes.reduce((count, node) => count + 1 + countNodes(node.children ?? []), 0);
-}
-function inspectionSubagentRunner() {
-    return {
-        async runSubagent() {
-            throw new Error("Context build inspection cannot execute subagents");
-        },
-    };
-}
-function inspectionRunToolController() {
-    const fail = () => {
-        throw new Error("Context build inspection cannot execute run-control tools");
-    };
-    return {
-        startToolRun: fail,
-        listRuns: () => [],
-        getRunStatus: fail,
-        waitForRun: fail,
-        readRun: fail,
-        cancelRun: fail,
-        ackRun: fail,
-    };
-}
-function withoutRequestedModels(profile) {
-    return new InitialSessionContext({
-        profileName: profile.profileName,
-        sessionId: profile.sessionId,
-        parentSessionId: profile.parentSessionId,
-        thinkingLevel: profile.thinkingLevel,
-        mainThinkingLevel: profile.mainThinkingLevel,
-        subagentThinkingLevel: profile.subagentThinkingLevel,
-        fast: profile.fast,
-        mainFast: profile.mainFast,
-        subagentFast: profile.subagentFast,
-        skills: profile.skills,
-        tools: profile.tools,
-        subagents: profile.subagents,
-        mcpServers: profile.mcpServers,
-        piPackages: profile.piPackages,
-        contextFiles: profile.contextFiles,
-        builtinTools: profile.builtinTools,
-        builtinToolNames: profile.builtinToolNames,
-        autoContextFiles: profile.autoContextFiles,
-        toolPackages: profile.toolPackages,
-    });
-}
-function resolveProfilePath(cwd, path) {
-    return path.startsWith("pibo://") ? path : resolve(cwd, path);
-}
-function activeModelFor(profile, options) {
-    return options.activeModel ?? profile.mainModel ?? profile.model;
-}
-function toolDefinitionSchema(definition, toolInfo) {
-    return definition?.parameters ?? toolInfo?.parameters;
-}
-function generatedOriginForTool(name, profile) {
-    if (name === "runtime")
-        return "Generated Pibo runtime tool selected by the profile.";
-    if (name.startsWith("pibo_subagent_"))
-        return "Generated subagent tool from the profile's subagent list.";
-    if (name.startsWith("pibo_run_"))
-        return "Generated run-control tool from the pibo-run-control capability package.";
-    if (name === "apply_patch" || name === "view_image")
-        return "Generated Codex-compatible tool from the codex-compat package.";
-    if (profile.builtinToolNames.includes(name) || DEFAULT_BUILTIN_TOOL_NAMES.includes(name))
-        return undefined;
-    return undefined;
-}
-function sourceForContextFile(path, profile, cwd) {
-    if (path === "pibo://runtime/session-context.md")
-        return "runtime";
-    if (path.endsWith(".pibo/context/installed-pibo-tools.md") || path === ".pibo/context/installed-pibo-tools.md")
-        return "generated";
-    if (path.endsWith(".pibo/context/enabled-mcp-servers.md") || path === ".pibo/context/enabled-mcp-servers.md")
-        return "generated";
-    const selected = profile.contextFiles.find((contextFile) => contextFile.enabled !== false && resolveProfilePath(cwd, contextFile.path) === path);
-    if (selected?.source === "managed")
-        return "managed";
-    if (selected?.source === "plugin")
-        return "plugin";
-    return selected ? "profile" : "pi";
-}
-function badgesForSource(source) {
-    switch (source) {
-        case "generated":
-        case "runtime":
-            return ["GENERATED"];
-        case "managed":
-            return ["MANAGED"];
-        case "plugin":
-            return ["PLUGIN"];
-        case "pi":
-            return ["PI"];
-        case "provider":
-            return ["PROVIDER"];
-        default:
-            return [];
-    }
-}
-async function readSkillMarkdown(path) {
-    try {
-        return await readFile(path, "utf-8");
-    }
-    catch {
-        return undefined;
-    }
-}
-// Skills are advertised to the model via a small XML summary in the system
-// prompt (see formatSkillsForPrompt in @earendil-works/pi-coding-agent). Only the
-// name, description, and location land in the prompt; the full SKILL.md body
-// is loaded lazily by the model via the read tool. Mirror that exact
-// per-skill entry shape here so the inspector's token estimate matches what
-// the model actually sees, instead of the full markdown body.
-function escapeXmlAttribute(value) {
-    return value
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&apos;");
-}
-function formatSkillEntryForPrompt(skill) {
-    return [
-        "  <skill>",
-        `    <name>${escapeXmlAttribute(skill.name)}</name>`,
-        `    <description>${escapeXmlAttribute(skill.description)}</description>`,
-        `    <location>${escapeXmlAttribute(skill.filePath)}</location>`,
-        "  </skill>",
-    ].join("\n");
-}
-function diagnosticsNodes(diagnostics) {
-    return diagnostics.map((diagnostic, index) => ({
-        id: `diagnostics/${index}`,
-        kind: "diagnostic",
-        title: diagnostic.type.toUpperCase(),
-        source: "runtime",
-        state: diagnostic.type === "error" ? "error" : diagnostic.type === "warning" ? "warning" : "active",
-        badges: [diagnostic.type.toUpperCase()],
-        hydratedText: diagnostic.message,
-        metadata: diagnostic.nodeId ? { nodeId: diagnostic.nodeId } : undefined,
-    }));
-}
-export async function inspectPiboContextBuild(options = {}) {
-    const cwd = options.cwd ?? getDefaultPiboWorkspace();
-    const profile = options.profile ?? createDefaultPiboProfile();
-    const inspectionProfile = withoutRequestedModels(profile);
-    const hasEnabledSubagents = profile.subagents.some((subagent) => subagent.enabled !== false);
-    const hasYieldableTools = profile.toolPackages.runControl === true ||
-        hasEnabledSubagents ||
-        profile.tools.some((tool) => tool.enabled !== false && tool.definition !== undefined && tool.yieldable !== false);
-    const runtime = await createPiboRuntime({
-        ...options,
-        cwd,
-        profile: inspectionProfile,
-        activeModel: undefined,
-        persistSession: false,
-        subagentRunner: options.subagentRunner ?? (hasEnabledSubagents ? inspectionSubagentRunner() : undefined),
-        runToolController: options.runToolController ?? (hasYieldableTools ? inspectionRunToolController() : undefined),
-    });
-    try {
-        const generatedAt = new Date().toISOString();
-        const resourceLoader = runtime.services.resourceLoader;
-        const basePrompt = await readPiboBasePrompt(cwd);
-        const activePrompt = basePrompt.effectiveMode === "custom" ? basePrompt.custom : basePrompt.library;
-        const activeToolNames = new Set(runtime.session.getActiveToolNames());
-        const allTools = runtime.session.getAllTools();
-        const toolInfoByName = new Map(allTools.map((tool) => [tool.name, tool]));
-        const providerTools = profile.tools.filter((tool) => tool.enabled !== false).filter(isWebSearchProviderTool);
-        const toolNames = [...new Set([...activeToolNames, ...providerTools.map((tool) => tool.name)])].sort((left, right) => left.localeCompare(right));
-        const selectedTools = [...activeToolNames];
-        const toolSnippets = {};
-        const promptGuidelines = [];
-        for (const name of selectedTools) {
-            const definition = runtime.session.getToolDefinition(name);
-            if (definition?.promptSnippet)
-                toolSnippets[name] = definition.promptSnippet;
-            if (definition?.promptGuidelines?.length)
-                promptGuidelines.push(...definition.promptGuidelines);
-        }
-        const diagnostics = runtime.diagnostics.map((diagnostic) => ({
-            type: diagnostic.type,
-            message: diagnostic.message,
-        }));
-        if (profile.autoContextFiles === false) {
-            diagnostics.push({ type: "info", message: "Pi automatic context files are disabled for this profile." });
-        }
-        const promptChildren = [
-            {
-                id: "prompt/base",
-                kind: "prompt_section",
-                title: "Pibo Base Prompt",
-                source: basePrompt.effectiveMode,
-                state: "active",
-                badges: [basePrompt.effectiveMode.toUpperCase(), "LOCKED"],
-                path: activePrompt.path,
-                bytes: byteLength(activePrompt.markdown),
-                metadata: { mode: basePrompt.mode, effectiveMode: basePrompt.effectiveMode },
-                hydratedText: activePrompt.markdown,
-            },
-        ];
-        if (hasPiboSystemPromptTemplateMarkers(activePrompt.markdown)) {
-            if (activePrompt.markdown.includes("{{availableTools}}")) {
-                const text = buildPiboAvailableTools({ selectedTools, toolSnippets });
-                promptChildren.push({
-                    id: "prompt/available-tools-marker",
-                    kind: "prompt_section",
-                    title: "Available Tools Marker",
-                    source: "generated",
-                    state: "active",
-                    badges: ["GENERATED"],
-                    key: "{{availableTools}}",
-                    hydratedText: text,
-                    bytes: byteLength(text),
-                    metadata: { toolCount: selectedTools.length, visibleSnippetCount: Object.keys(toolSnippets).length },
-                });
-            }
-            if (activePrompt.markdown.includes("{{guidelines}}")) {
-                const text = buildPiboGuidelines({ selectedTools, promptGuidelines });
-                promptChildren.push({
-                    id: "prompt/guidelines-marker",
-                    kind: "prompt_section",
-                    title: "Guidelines Marker",
-                    source: "generated",
-                    state: "active",
-                    badges: ["GENERATED"],
-                    key: "{{guidelines}}",
-                    hydratedText: text,
-                    bytes: byteLength(text),
-                    metadata: { guidelineCount: text.split("\n").filter(Boolean).length },
-                });
-            }
-        }
-        if (profile.toolPackages.codexCompat === true) {
-            const marker = "\n\n[base prompt continues here]";
-            const wrapper = buildCodexCompatSystemPrompt({
-                baseSystemPrompt: marker.trimStart(),
-                cwd,
-                shell: process.env.SHELL ?? "bash",
-                isChildSession: profile.parentSessionId !== undefined,
-            }).replace(marker.trimStart(), "[base prompt continues here]");
-            promptChildren.unshift({
-                id: "prompt/codex-compat-wrapper",
-                kind: "runtime_extension",
-                title: "Codex Compatibility Wrapper",
-                source: "generated",
-                state: "active",
-                badges: ["GENERATED", "APPROX"],
-                hydratedText: wrapper,
-                approximate: true,
-                notes: ["Shows deterministic wrapper text with a placeholder instead of duplicating the full base prompt."],
-            });
-        }
-        for (const tool of providerTools) {
-            if (tool.providerTool.kind !== "web_search")
-                continue;
-            promptChildren.push({
-                id: `prompt/provider/${tool.name}`,
-                kind: "runtime_extension",
-                title: "Native Web Search Prompt Contribution",
-                source: "provider",
-                state: "active",
-                provider: tool.providerTool.provider,
-                badges: ["PROVIDER", "PROVIDER-BACKED"],
-                hydratedText: WEB_SEARCH_PROMPT_CONTRIBUTION,
-                metadata: { tool: tool.name, provider: tool.providerTool.provider },
-            });
-        }
-        const toolChildren = toolNames.map((name) => {
-            const providerTool = providerTools.find((tool) => tool.name === name);
-            const definition = runtime.session.getToolDefinition(name);
-            const info = toolInfoByName.get(name);
-            const children = [];
-            if (definition?.promptSnippet) {
-                children.push({
-                    id: `tools/${name}/prompt-snippet`,
-                    kind: "tool_prompt_snippet",
-                    title: "Prompt Snippet",
-                    source: providerTool ? "provider" : "pi",
-                    state: "active",
-                    hydratedText: definition.promptSnippet,
-                });
-            }
-            if (definition?.promptGuidelines?.length) {
-                children.push({
-                    id: `tools/${name}/prompt-guidelines`,
-                    kind: "tool_prompt_guidelines",
-                    title: "Prompt Guidelines",
-                    source: providerTool ? "provider" : "pi",
-                    state: "active",
-                    hydratedText: definition.promptGuidelines.map((guideline) => `- ${guideline}`).join("\n"),
-                    metadata: { guidelineCount: definition.promptGuidelines.length },
-                });
-            }
-            const schema = toolDefinitionSchema(definition, info);
-            if (schema !== undefined) {
-                children.push({
-                    id: `tools/${name}/definition`,
-                    kind: "tool_definition",
-                    title: "Tool Definition / Schema",
-                    source: providerTool ? "provider" : "pi",
-                    state: "active",
-                    schemaJson: {
-                        name,
-                        description: definition?.description ?? info?.description,
-                        parameters: schema,
-                    },
-                });
-            }
-            const generatedOrigin = generatedOriginForTool(name, profile);
-            if (generatedOrigin) {
-                children.push({
-                    id: `tools/${name}/generated-origin`,
-                    kind: "metadata",
-                    title: "Generated Origin",
-                    source: "generated",
-                    state: "active",
-                    badges: ["GENERATED"],
-                    hydratedText: generatedOrigin,
-                });
-            }
-            if (providerTool?.providerTool.kind === "web_search") {
-                children.push({
-                    id: `tools/${name}/provider-payload`,
-                    kind: "provider_payload",
-                    title: "Provider Payload",
-                    source: "provider",
-                    state: "active",
-                    provider: providerTool.providerTool.provider,
-                    badges: ["PROVIDER-BACKED"],
-                    payloadJson: {
-                        provider: providerTool.providerTool.provider,
-                        toolKind: providerTool.providerTool.kind,
-                        openAiWebSearch: normalizeOpenAiWebSearchConfig(providerTool.providerTool.options),
-                    },
-                });
-                children.push({
-                    id: `tools/${name}/provider-prompt`,
-                    kind: "tool_prompt_snippet",
-                    title: "Provider Prompt Contribution",
-                    source: "provider",
-                    state: "active",
-                    hydratedText: WEB_SEARCH_PROMPT_CONTRIBUTION,
-                });
-            }
-            if (children.length === 0) {
-                children.push({
-                    id: `tools/${name}/no-prompt-text`,
-                    kind: "metadata",
-                    title: "No Prompt Text",
-                    source: providerTool ? "provider" : "pi",
-                    state: "active",
-                    hydratedText: "This tool has no separate prompt snippet or guideline exposed by Pi. Its callable schema is the model-visible contribution.",
-                    approximate: true,
-                });
-            }
-            const badges = [
-                "ACTIVE",
-                ...(providerTool ? ["PROVIDER-BACKED"] : []),
-                ...(generatedOrigin ? ["GENERATED"] : []),
-                ...(profile.builtinToolNames.includes(name) || DEFAULT_BUILTIN_TOOL_NAMES.includes(name) ? ["PI"] : []),
-            ];
-            return {
-                id: `tools/${name}`,
-                kind: "tool",
-                title: name,
-                source: providerTool ? "provider" : generatedOrigin ? "generated" : "pi",
-                state: "active",
-                provider: providerTool?.providerTool.provider,
-                badges,
-                metadata: {
-                    registered: Boolean(info || providerTool),
-                    hasDefinition: Boolean(definition || info),
-                    description: definition?.description ?? info?.description ?? providerTool?.description,
-                },
-                children,
-            };
-        });
-        const agentsFiles = resourceLoader.getAgentsFiles().agentsFiles;
-        const installedToolContextFile = getInstalledCliToolContextFile();
-        const mcpAgentContextFile = await getMcpAgentContextFile(profile.mcpServers);
-        const contextChildren = agentsFiles.map((contextFile) => {
-            const source = contextFile.path === installedToolContextFile?.path
-                ? "generated"
-                : contextFile.path === mcpAgentContextFile?.path
-                    ? "generated"
-                    : sourceForContextFile(contextFile.path, profile, cwd);
-            return {
-                id: `context-files/${contextFile.path}`,
-                kind: "context_file",
-                title: contextFile.path.split("/").pop() || contextFile.path,
-                source,
-                state: "active",
-                path: contextFile.path,
-                bytes: byteLength(contextFile.content),
-                badges: [...badgesForSource(source), ...(contextFile.path === "pibo://runtime/session-context.md" ? ["LOCKED"] : [])],
-                metadata: { path: contextFile.path },
-                hydratedText: contextFile.content,
-            };
-        });
-        const skills = resourceLoader.getSkills().skills;
-        const skillChildren = [];
-        for (const skill of skills) {
-            const markdown = await readSkillMarkdown(skill.filePath);
-            const promptEntry = formatSkillEntryForPrompt(skill);
-            // The skill node reports only what is actually part of the model
-            // prompt: the formatted <skill>...</skill> entry. The full
-            // SKILL.md body is loaded lazily by the model via the read tool
-            // (or explicitly via /skill:name / $skill-name), so it must not
-            // inflate the model-context token estimate. The full file path
-            // and size are still surfaced via metadata for inspection.
-            skillChildren.push({
-                id: `skills/${skill.name}`,
-                kind: "skill",
-                title: skill.name,
-                source: "plugin",
-                path: skill.filePath,
-                bytes: byteLength(promptEntry),
-                badges: ["ACTIVE"],
-                metadata: {
-                    description: skill.description,
-                    filePath: skill.filePath,
-                    disableModelInvocation: skill.disableModelInvocation,
-                    fullFileBytes: markdown ? byteLength(markdown) : undefined,
-                    fullFileLoadableBy: "read tool, /skill:name command, $skill-name inline expansion",
-                },
-                hydratedText: markdown === undefined
-                    ? `Skill metadata is loaded, but ${skill.filePath} could not be read for inspection.`
-                    : promptEntry,
-                state: markdown ? "active" : "warning",
-            });
-        }
-        const extensionChildren = [];
-        if (providerTools.length > 0) {
-            extensionChildren.push(...providerTools.map((tool) => ({
-                id: `runtime-extensions/provider-${tool.name}`,
-                kind: "runtime_extension",
-                title: `${tool.name} Provider Adapter`,
-                source: "provider",
-                state: "active",
-                provider: tool.providerTool.provider,
-                badges: ["PROVIDER", "PROVIDER-BACKED"],
-                metadata: { kind: tool.providerTool.kind, provider: tool.providerTool.provider },
-                payloadJson: tool.providerTool.kind === "web_search" ? normalizeOpenAiWebSearchConfig(tool.providerTool.options) : undefined,
-                hydratedText: tool.providerTool.kind === "web_search" ? WEB_SEARCH_PROMPT_CONTRIBUTION : undefined,
-            })));
-        }
-        if (profile.toolPackages.codexCompat === true) {
-            extensionChildren.push({
-                id: "runtime-extensions/codex-compat",
-                kind: "runtime_extension",
-                title: "Codex Compatibility",
-                source: "generated",
-                state: "active",
-                badges: ["GENERATED"],
-                hydratedText: "Codex compatibility wraps the base system prompt and adds apply_patch/view_image tools when enabled.",
-            });
-        }
-        const topLevel = [
-            {
-                id: "prompt",
-                kind: "prompt_section",
-                title: "Prompt / Runtime Shell",
-                source: "runtime",
-                state: "active",
-                badges: ["ACTIVE"],
-                metadata: { childCount: promptChildren.length, activeModel: activeModelFor(profile, options) },
-                children: promptChildren,
-            },
-            {
-                id: "tools",
-                kind: "tool_surface",
-                title: "Tool Prompt Surface",
-                source: "runtime",
-                state: "active",
-                badges: ["ACTIVE"],
-                metadata: {
-                    activeTools: toolNames.length,
-                    generatedTools: toolChildren.filter((node) => node.badges?.includes("GENERATED")).length,
-                    builtInTools: toolNames.filter((name) => profile.builtinToolNames.includes(name)).length,
-                    nativeTools: profile.tools.filter((tool) => tool.enabled !== false).length,
-                    providerBackedTools: providerTools.length,
-                },
-                children: toolChildren,
-            },
-            {
-                id: "context-files",
-                kind: "context_files",
-                title: "Context Files",
-                source: "runtime",
-                state: "active",
-                badges: [profile.autoContextFiles === false ? "PI AUTO DISABLED" : "ACTIVE"],
-                metadata: {
-                    childCount: contextChildren.length,
-                    autoContextFiles: profile.autoContextFiles,
-                    installedToolContext: Boolean(installedToolContextFile),
-                    mcpContext: Boolean(mcpAgentContextFile),
-                },
-                children: contextChildren,
-            },
-            {
-                id: "skills",
-                kind: "skills",
-                title: "Skills",
-                source: "runtime",
-                state: skillChildren.length > 0 ? "active" : "disabled",
-                badges: skillChildren.length > 0 ? ["ACTIVE"] : ["EMPTY"],
-                metadata: { childCount: skillChildren.length },
-                children: skillChildren,
-            },
-            {
-                id: "runtime-extensions",
-                kind: "runtime_extension",
-                title: "Runtime Extensions",
-                source: "runtime",
-                state: extensionChildren.length > 0 ? "active" : "disabled",
-                badges: extensionChildren.length > 0 ? ["ACTIVE"] : ["EMPTY"],
-                metadata: { childCount: extensionChildren.length },
-                children: extensionChildren,
-            },
-            {
-                id: "diagnostics",
-                kind: "diagnostic",
-                title: "Diagnostics",
-                source: "runtime",
-                state: diagnostics.some((diagnostic) => diagnostic.type === "error") ? "error" : diagnostics.some((diagnostic) => diagnostic.type === "warning") ? "warning" : "active",
-                badges: diagnostics.length > 0 ? ["DIAGNOSTICS"] : ["OK"],
-                metadata: {
-                    warnings: diagnostics.filter((diagnostic) => diagnostic.type === "warning").length,
-                    errors: diagnostics.filter((diagnostic) => diagnostic.type === "error").length,
-                    infos: diagnostics.filter((diagnostic) => diagnostic.type === "info").length,
-                },
-                children: diagnostics.length ? diagnosticsNodes(diagnostics) : [{
-                        id: "diagnostics/none",
-                        kind: "diagnostic",
-                        title: "No Diagnostics",
-                        source: "runtime",
-                        state: "active",
-                        hydratedText: "No warnings or errors were reported while assembling this snapshot.",
-                    }],
-            },
-        ];
-        const nodes = topLevel.map((node, index) => sanitizeNode(node, undefined, index));
-        const estimatedTokens = nodes.reduce((total, node) => total + (node.estimatedSubtreeTokens ?? node.estimatedTokens ?? 0), 0);
-        const redactedDiagnostics = diagnostics.map((diagnostic) => {
-            const result = redactText(diagnostic.message);
-            return { ...diagnostic, message: result.value };
-        });
-        return {
-            version: 1,
-            generatedAt,
-            profileName: profile.profileName,
-            piboSessionId: options.sessionContext?.piboSessionId,
-            piboRoomId: options.sessionContext?.piboRoomId,
-            cwd,
-            activeModel: activeModelFor(profile, options),
-            summary: {
-                topLevelNodes: nodes.length,
-                totalNodes: countNodes(nodes),
-                estimatedTokens,
-                warnings: redactedDiagnostics.filter((diagnostic) => diagnostic.type === "warning").length,
-                errors: redactedDiagnostics.filter((diagnostic) => diagnostic.type === "error").length,
-            },
-            nodes,
-            diagnostics: redactedDiagnostics,
-        };
-    }
-    finally {
-        await runtime.dispose();
-    }
-}
-export function createContextBuildSessionContext(input) {
-    return input ? { ...input } : undefined;
-}