@pasko70/pibo 1.9.9 → 1.9.11

package/dist/core/context-guard.js

@@ -0,0 +1,293 @@
+import { DEFAULT_COMPACTION_SETTINGS, buildSessionContext, estimateTokens, } from "@earendil-works/pi-coding-agent";
+export const PIBO_CONTEXT_GUARD_NOTICE = "Context safety interrupted this response before adding it to long-term context. Pibo is compacting the session before continuing.";
+export const PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE = "pibo-context-guard-resume";
+export const PIBO_CONTEXT_GUARD_RESUME_PROMPT = "Continue the interrupted task autonomously from the compacted context. Do not wait for additional user input and do not repeat the context-safety notice.";
+const DEFAULT_MIN_COMPACTION_RESERVE_TOKENS = 1024;
+const FALLBACK_CONTEXT_WINDOW = 0;
+const MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS = 3;
+const contextGuardRecoveries = new WeakMap();
+export function createPiboAssistantContextGuardRecovery() {
+    let pending;
+    let claimed = false;
+    let cancelError;
+    let cancelHandler;
+    return {
+        begin() {
+            if (pending && !pending.settled)
+                return;
+            cancelError = undefined;
+            let resolve;
+            const promise = new Promise((done) => {
+                resolve = done;
+            });
+            pending = { promise, resolve, settled: false };
+        },
+        complete() {
+            if (!pending || pending.settled)
+                return;
+            pending.settled = true;
+            pending.resolve({ ok: true });
+        },
+        fail(error) {
+            if (!pending || pending.settled)
+                return;
+            pending.settled = true;
+            pending.resolve({ ok: false, error });
+        },
+        cancel(error) {
+            cancelError = error;
+            if (pending && !pending.settled) {
+                pending.settled = true;
+                pending.resolve({ ok: false, error });
+            }
+            cancelHandler?.();
+        },
+        claim() {
+            claimed = true;
+        },
+        isClaimed() {
+            return claimed;
+        },
+        isPending() {
+            return pending !== undefined && !pending.settled;
+        },
+        onCancel(handler) {
+            cancelHandler = handler;
+        },
+        async wait() {
+            const current = pending;
+            if (!current)
+                return false;
+            const outcome = await current.promise;
+            const cancelled = cancelError;
+            if (pending === current) {
+                pending = undefined;
+                cancelError = undefined;
+            }
+            if (cancelled)
+                throw cancelled;
+            if (!outcome.ok)
+                throw outcome.error;
+            return true;
+        },
+    };
+}
+export function registerPiboAssistantContextGuardRecovery(session, recovery) {
+    contextGuardRecoveries.set(session, recovery);
+}
+export function claimPiboAssistantContextGuardRecovery(session) {
+    contextGuardRecoveries.get(session)?.claim();
+}
+export function cancelPiboAssistantContextGuardRecovery(session, error) {
+    contextGuardRecoveries.get(session)?.cancel(error);
+}
+export function isPiboAssistantContextGuardRecoveryPending(session) {
+    return contextGuardRecoveries.get(session)?.isPending() ?? false;
+}
+export async function waitForPiboAssistantContextGuardRecovery(session) {
+    return await contextGuardRecoveries.get(session)?.wait() ?? false;
+}
+function textTokensByLength(length) {
+    return Math.ceil(length / 4);
+}
+function finitePositive(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function guardReserveTokens(contextWindow, options) {
+    const configured = finitePositive(options.reserveTokens);
+    if (configured !== undefined)
+        return configured;
+    const minReserve = finitePositive(options.minReserveTokens) ?? DEFAULT_MIN_COMPACTION_RESERVE_TOKENS;
+    const requestedReserve = Math.max(minReserve, Math.floor(contextWindow * 0.2));
+    return Math.min(DEFAULT_COMPACTION_SETTINGS.reserveTokens ?? 16384, requestedReserve, Math.floor(contextWindow * 0.5));
+}
+function estimateMessageTokens(message) {
+    return estimateTokens(message);
+}
+function estimateBranchContextTokens(ctx) {
+    const leafId = ctx.sessionManager.getLeafId();
+    const branch = ctx.sessionManager.getBranch(leafId ?? undefined);
+    const sessionContext = buildSessionContext(branch, leafId);
+    return sessionContext.messages.reduce((tokens, message) => tokens + estimateMessageTokens(message), 0);
+}
+function contextWindowFrom(ctx) {
+    const usageWindow = finitePositive(ctx.getContextUsage()?.contextWindow);
+    if (usageWindow !== undefined)
+        return usageWindow;
+    return finitePositive(ctx.model?.contextWindow) ?? FALLBACK_CONTEXT_WINDOW;
+}
+function baselineContextTokens(ctx) {
+    const usageTokens = finitePositive(ctx.getContextUsage()?.tokens);
+    const estimatedTokens = estimateBranchContextTokens(ctx);
+    return usageTokens === undefined ? estimatedTokens : Math.max(usageTokens, estimatedTokens);
+}
+export function projectAssistantContextGuard(ctx, assistantTokens, options = {}) {
+    const contextWindow = contextWindowFrom(ctx);
+    if (contextWindow <= 0)
+        return undefined;
+    const contextTokens = baselineContextTokens(ctx);
+    const reserveTokens = guardReserveTokens(contextWindow, options);
+    const projectedTokens = contextTokens + assistantTokens + reserveTokens;
+    return {
+        contextTokens,
+        assistantTokens,
+        reserveTokens,
+        contextWindow,
+        projectedTokens,
+        exceedsLimit: projectedTokens > contextWindow,
+    };
+}
+function assistantDeltaChars(event) {
+    if (!event.assistantMessageEvent || typeof event.assistantMessageEvent !== "object")
+        return 0;
+    const assistantEvent = event.assistantMessageEvent;
+    if (typeof assistantEvent.delta === "string")
+        return assistantEvent.delta.length;
+    if (typeof assistantEvent.content === "string")
+        return assistantEvent.content.length;
+    if (assistantEvent.toolCall) {
+        return String(assistantEvent.toolCall.name ?? "").length + JSON.stringify(assistantEvent.toolCall.arguments ?? {}).length;
+    }
+    return 0;
+}
+function replacementAssistantMessage(message) {
+    return {
+        ...message,
+        content: [{ type: "text", text: PIBO_CONTEXT_GUARD_NOTICE }],
+        stopReason: "aborted",
+        errorMessage: undefined,
+    };
+}
+function compactionInstructions(projection) {
+    const usage = projection
+        ? ` Projected context was ${projection.projectedTokens} / ${projection.contextWindow} tokens, including ${projection.assistantTokens} tokens from the interrupted assistant response and ${projection.reserveTokens} reserved tokens for compaction.`
+        : "";
+    return `Pibo interrupted the previous assistant response before persisting the full output because it would exceed the safe context budget.${usage} Summarize the durable conversation up to the guard notice, preserve the user's current task and important recent facts, and leave enough context budget for the next response.`;
+}
+export function createPiboAssistantContextGuardExtension(options = {}, recovery = createPiboAssistantContextGuardRecovery()) {
+    return (pi) => {
+        const state = {
+            deltaChars: 0,
+            tripped: false,
+            compactQueued: false,
+            resumeRequested: false,
+            resumeInProgress: false,
+            resumeSettling: false,
+            recoveryAttempts: 0,
+        };
+        function resetAssistantState() {
+            state.deltaChars = 0;
+            state.tripped = false;
+            state.compactQueued = false;
+            state.lastProjection = undefined;
+        }
+        function clearResumeStartTimer() {
+            if (state.resumeStartTimer === undefined)
+                return;
+            clearTimeout(state.resumeStartTimer);
+            state.resumeStartTimer = undefined;
+        }
+        function resetRecoveryState() {
+            clearResumeStartTimer();
+            state.tripped = false;
+            state.compactQueued = false;
+            state.resumeRequested = false;
+            state.resumeInProgress = false;
+            state.resumeSettling = false;
+            state.recoveryAttempts = 0;
+        }
+        function failRecovery(error) {
+            resetRecoveryState();
+            recovery.fail(error);
+        }
+        recovery.onCancel(resetRecoveryState);
+        function tripIfNeeded(ctx, assistantTokens) {
+            const projection = projectAssistantContextGuard(ctx, assistantTokens, options);
+            state.lastProjection = projection;
+            if (!projection?.exceedsLimit)
+                return false;
+            state.tripped = true;
+            return true;
+        }
+        pi.on("agent_start", () => {
+            if (!state.resumeRequested)
+                return;
+            clearResumeStartTimer();
+            state.resumeRequested = false;
+            state.resumeInProgress = true;
+        });
+        pi.on("agent_settled", () => {
+            if (!state.resumeSettling)
+                return;
+            state.resumeSettling = false;
+            state.recoveryAttempts = 0;
+            recovery.complete();
+        });
+        pi.on("message_start", (event) => {
+            if (event.message.role === "assistant")
+                resetAssistantState();
+        });
+        pi.on("message_update", (event, ctx) => {
+            if (event.message.role !== "assistant")
+                return;
+            state.deltaChars += assistantDeltaChars(event);
+            const assistantTokens = Math.max(estimateMessageTokens(event.message), textTokensByLength(state.deltaChars));
+            if (tripIfNeeded(ctx, assistantTokens))
+                ctx.abort();
+        });
+        pi.on("message_end", (event, ctx) => {
+            if (event.message.role !== "assistant")
+                return;
+            const assistantTokens = Math.max(estimateMessageTokens(event.message), textTokensByLength(state.deltaChars));
+            if (!state.tripped && !tripIfNeeded(ctx, assistantTokens))
+                return;
+            return { message: replacementAssistantMessage(event.message) };
+        });
+        pi.on("agent_end", (_event, ctx) => {
+            if (state.tripped && !state.compactQueued) {
+                if (state.recoveryAttempts >= MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS) {
+                    failRecovery(new Error(`Context guard recovery exceeded ${MAX_CONTEXT_GUARD_RECOVERY_ATTEMPTS} compaction attempts`));
+                    return;
+                }
+                state.compactQueued = true;
+                state.recoveryAttempts++;
+                recovery.begin();
+                let callbackHandled = false;
+                ctx.compact({
+                    customInstructions: compactionInstructions(state.lastProjection),
+                    onComplete: () => {
+                        if (callbackHandled || !recovery.isPending())
+                            return;
+                        callbackHandled = true;
+                        state.tripped = false;
+                        state.compactQueued = false;
+                        state.resumeRequested = true;
+                        if (recovery.isClaimed()) {
+                            recovery.complete();
+                            return;
+                        }
+                        state.resumeStartTimer = setTimeout(() => {
+                            failRecovery(new Error("Context guard continuation did not start"));
+                        }, 5000);
+                        pi.sendMessage({
+                            customType: PIBO_CONTEXT_GUARD_RESUME_MESSAGE_TYPE,
+                            content: [{ type: "text", text: PIBO_CONTEXT_GUARD_RESUME_PROMPT }],
+                            display: false,
+                        }, { triggerTurn: true });
+                    },
+                    onError: (error) => {
+                        if (callbackHandled || !recovery.isPending())
+                            return;
+                        callbackHandled = true;
+                        failRecovery(error);
+                    },
+                });
+                return;
+            }
+            if (!state.resumeInProgress)
+                return;
+            state.resumeInProgress = false;
+            state.resumeSettling = true;
+        });
+    };
+}

package/dist/core/events.js

@@ -0,0 +1 @@
+export {};

package/dist/core/gateway-resource-guard.js

@@ -0,0 +1,215 @@
+import { execFile } from "node:child_process";
+import { freemem, totalmem } from "node:os";
+import { promisify } from "node:util";
+import { getHeapStatistics } from "node:v8";
+const execFileAsync = promisify(execFile);
+const DEFAULT_POLICY = Object.freeze({
+    mode: "warn",
+    minFreeMemoryBytes: 256 * 1024 * 1024,
+    minHeapAvailableBytes: 64 * 1024 * 1024,
+    maxRssBytes: 1536 * 1024 * 1024,
+    knownDaemonWarningRssBytes: 2 * 1024 * 1024 * 1024,
+});
+export function resolveGatewayResourceGuardPolicy(env = process.env) {
+    return {
+        mode: parseMode(env.PIBO_GATEWAY_RESOURCE_GUARD, DEFAULT_POLICY.mode),
+        minFreeMemoryBytes: parseByteThreshold(env.PIBO_GATEWAY_MIN_FREE_MEMORY_BYTES, DEFAULT_POLICY.minFreeMemoryBytes),
+        minHeapAvailableBytes: parseByteThreshold(env.PIBO_GATEWAY_MIN_HEAP_AVAILABLE_BYTES, DEFAULT_POLICY.minHeapAvailableBytes),
+        maxRssBytes: parseByteThreshold(env.PIBO_GATEWAY_MAX_RSS_BYTES, DEFAULT_POLICY.maxRssBytes),
+        knownDaemonWarningRssBytes: parseByteThreshold(env.PIBO_GATEWAY_KNOWN_DAEMON_WARNING_RSS_BYTES, DEFAULT_POLICY.knownDaemonWarningRssBytes),
+    };
+}
+export function collectGatewayProcessMemory() {
+    const memory = process.memoryUsage();
+    const heap = getHeapStatistics();
+    return {
+        pid: process.pid,
+        rssBytes: memory.rss,
+        heapUsedBytes: memory.heapUsed,
+        heapTotalBytes: memory.heapTotal,
+        heapLimitBytes: heap.heap_size_limit,
+        heapAvailableBytes: Math.max(0, heap.heap_size_limit - memory.heapUsed),
+        externalBytes: memory.external,
+        arrayBuffersBytes: memory.arrayBuffers,
+    };
+}
+export function buildGatewayResourceSnapshot(options = {}) {
+    const policy = resolveGatewayResourceGuardPolicy(options.env);
+    const gateway = collectGatewayProcessMemory();
+    const host = { freeBytes: freemem(), totalBytes: totalmem() };
+    const processResult = processResultFromOptions(gateway.pid, options, policy);
+    const checks = evaluateGatewayResourceChecks({ gateway, host, policy, knownDaemons: processResult.knownDaemons });
+    const severity = maxSeverity(checks.map((check) => check.severity));
+    return {
+        generatedAt: (options.now ?? new Date()).toISOString(),
+        readOnly: true,
+        policy,
+        gateway,
+        host,
+        checks,
+        processes: processResult,
+        severity,
+        guardAction: guardAction(policy, severity),
+        nextCommands: [
+            "pibo debug resources --json",
+            "pibo compute health --json",
+            "pibo debug telemetry sessions --active",
+            "pibo debug runs list <pibo-session-id> --json",
+        ],
+    };
+}
+export async function collectGatewayResourceSnapshot(options = {}) {
+    if (options.includeProcesses === false || options.processListOutput !== undefined || options.processListError !== undefined) {
+        return buildGatewayResourceSnapshot(options);
+    }
+    try {
+        const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,rss=,comm=,args="], { maxBuffer: 10 * 1024 * 1024 });
+        return buildGatewayResourceSnapshot({ ...options, processListOutput: stdout });
+    }
+    catch (error) {
+        return buildGatewayResourceSnapshot({ ...options, processListError: error instanceof Error ? error.message : String(error) });
+    }
+}
+export function assertGatewayResourceAvailableForWork(workLabel, env = process.env) {
+    const snapshot = buildGatewayResourceSnapshot({ env, includeProcesses: false });
+    if (snapshot.guardAction !== "block")
+        return;
+    const reasons = snapshot.checks.filter((check) => check.severity === "critical").map((check) => check.message).join("; ");
+    throw new Error(`Gateway resource guard blocked ${workLabel} before starting: ${reasons}`);
+}
+export function parseHostProcessResourceList(output, gatewayPid, policy = DEFAULT_POLICY) {
+    const rows = [];
+    for (const line of output.split("\n")) {
+        if (!line.trim())
+            continue;
+        const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s*(.*)$/);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const ppid = Number(match[2]);
+        const rssBytes = Number(match[3]) * 1024;
+        if (!Number.isInteger(pid) || !Number.isInteger(ppid) || !Number.isFinite(rssBytes))
+            continue;
+        const commandName = match[4] ?? "";
+        const args = match[5] ?? "";
+        const daemonLabel = knownDaemonLabel(commandName, args);
+        const kind = pid === gatewayPid ? "gateway" : ppid === gatewayPid ? "child" : daemonLabel ? "known-daemon" : "other";
+        rows.push({ pid, ppid, rssBytes, commandName, args: sanitizeArgsPreview(args), kind, label: daemonLabel });
+    }
+    return rows
+        .filter((row) => row.kind === "gateway" || row.kind === "child" || row.kind === "known-daemon")
+        .sort((a, b) => resourceProcessRank(a, policy) - resourceProcessRank(b, policy) || b.rssBytes - a.rssBytes);
+}
+export function renderGatewayResourceSnapshotText(snapshot) {
+    const lines = [`Gateway resource health: ${snapshot.severity} (guard=${snapshot.policy.mode}, action=${snapshot.guardAction})`];
+    lines.push(`Generated at: ${snapshot.generatedAt}`);
+    lines.push(`Gateway PID: ${snapshot.gateway.pid}`);
+    lines.push(`Gateway memory: rss=${snapshot.gateway.rssBytes} heapUsed=${snapshot.gateway.heapUsedBytes} heapAvailable=${snapshot.gateway.heapAvailableBytes} heapLimit=${snapshot.gateway.heapLimitBytes}`);
+    lines.push(`Host memory: free=${snapshot.host.freeBytes} total=${snapshot.host.totalBytes}`);
+    lines.push(`Thresholds: minFree=${snapshot.policy.minFreeMemoryBytes} minHeapAvailable=${snapshot.policy.minHeapAvailableBytes} maxRss=${snapshot.policy.maxRssBytes} daemonWarnRss=${snapshot.policy.knownDaemonWarningRssBytes}`);
+    lines.push(`Related processes: children=${snapshot.processes.children.length} knownDaemons=${snapshot.processes.knownDaemons.length} processList=${snapshot.processes.available ? "available" : "unavailable"}`);
+    if (snapshot.processes.error)
+        lines.push(`Process list error: ${snapshot.processes.error}`);
+    const visibleProcesses = [...snapshot.processes.children, ...snapshot.processes.knownDaemons].slice(0, 10);
+    if (visibleProcesses.length > 0) {
+        lines.push("PID\tPPID\tRSS_BYTES\tKIND\tLABEL\tCOMMAND");
+        for (const process of visibleProcesses) {
+            lines.push(`${process.pid}\t${process.ppid}\t${process.rssBytes}\t${process.kind}\t${process.label ?? "-"}\t${process.commandName}`);
+        }
+    }
+    lines.push("Checks:");
+    for (const check of snapshot.checks)
+        lines.push(`- [${check.severity}] ${check.id}: ${check.message}`);
+    lines.push("Next commands:");
+    for (const command of snapshot.nextCommands)
+        lines.push(`- ${command}`);
+    return lines.join("\n");
+}
+function evaluateGatewayResourceChecks(input) {
+    const checks = [];
+    if (input.policy.mode === "off") {
+        checks.push({ id: "guard-disabled", severity: "ok", message: "Gateway resource guard is disabled." });
+        return checks;
+    }
+    checks.push(input.host.freeBytes < input.policy.minFreeMemoryBytes
+        ? { id: "host-memory-reserve", severity: "critical", message: `Host free memory ${input.host.freeBytes} is below reserve ${input.policy.minFreeMemoryBytes}.` }
+        : { id: "host-memory-reserve", severity: "ok", message: `Host free memory ${input.host.freeBytes} satisfies reserve ${input.policy.minFreeMemoryBytes}.` });
+    checks.push(input.gateway.heapAvailableBytes < input.policy.minHeapAvailableBytes
+        ? { id: "gateway-heap-reserve", severity: "critical", message: `Gateway heap availability ${input.gateway.heapAvailableBytes} is below reserve ${input.policy.minHeapAvailableBytes}.` }
+        : { id: "gateway-heap-reserve", severity: "ok", message: `Gateway heap availability ${input.gateway.heapAvailableBytes} satisfies reserve ${input.policy.minHeapAvailableBytes}.` });
+    checks.push(input.gateway.rssBytes > input.policy.maxRssBytes
+        ? { id: "gateway-rss-limit", severity: "critical", message: `Gateway RSS ${input.gateway.rssBytes} exceeds limit ${input.policy.maxRssBytes}.` }
+        : { id: "gateway-rss-limit", severity: "ok", message: `Gateway RSS ${input.gateway.rssBytes} is within limit ${input.policy.maxRssBytes}.` });
+    const heavyDaemons = input.knownDaemons.filter((process) => process.rssBytes >= input.policy.knownDaemonWarningRssBytes);
+    if (heavyDaemons.length > 0)
+        checks.push({ id: "known-heavy-daemons", severity: "warning", message: `${heavyDaemons.length} known heavy daemon(s) exceed RSS warning threshold: ${heavyDaemons.map((process) => `${process.label ?? process.commandName}:${process.rssBytes}`).join(", ")}.` });
+    return checks;
+}
+function processResultFromOptions(gatewayPid, options, policy) {
+    if (options.processListError)
+        return { available: false, error: options.processListError, gatewayPid, children: [], knownDaemons: [] };
+    if (options.processListOutput === undefined)
+        return { available: false, gatewayPid, children: [], knownDaemons: [] };
+    const rows = parseHostProcessResourceList(options.processListOutput, gatewayPid, policy);
+    return {
+        available: true,
+        gatewayPid,
+        children: rows.filter((row) => row.kind === "child"),
+        knownDaemons: rows.filter((row) => row.kind === "known-daemon"),
+    };
+}
+function parseMode(value, fallback) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "off" || normalized === "0" || normalized === "false")
+        return "off";
+    if (normalized === "block" || normalized === "strict")
+        return "block";
+    if (normalized === "warn" || normalized === "1" || normalized === "true" || normalized === undefined || normalized === "")
+        return "warn";
+    return fallback;
+}
+function parseByteThreshold(value, fallback) {
+    if (value === undefined || value.trim() === "")
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
+}
+function knownDaemonLabel(commandName, args) {
+    const combined = `${commandName} ${args}`;
+    if (/comfyui|main\.py.*--port\s+8188/i.test(combined))
+        return "ComfyUI";
+    if (/unity(\.exe)?|Unity Editor/i.test(combined))
+        return "Unity";
+    return undefined;
+}
+function sanitizeArgsPreview(args) {
+    const redacted = args
+        .replace(/(token|access_token|refresh_token|password|passwd|cookie|secret)=([^\s]+)/gi, "$1=<redacted>")
+        .replace(/(--(?:token|password|cookie|secret))\s+([^\s]+)/gi, "$1 <redacted>");
+    return redacted.length > 220 ? `${redacted.slice(0, 217)}...` : redacted;
+}
+function resourceProcessRank(process, policy) {
+    if (process.kind === "gateway")
+        return 0;
+    if (process.kind === "child")
+        return 1;
+    if (process.rssBytes >= policy.knownDaemonWarningRssBytes)
+        return 2;
+    return 3;
+}
+function guardAction(policy, severity) {
+    if (policy.mode === "off")
+        return "allow";
+    if (policy.mode === "block" && severity === "critical")
+        return "block";
+    if (severity === "warning" || severity === "critical")
+        return "warn";
+    return "allow";
+}
+function maxSeverity(values) {
+    if (values.includes("critical"))
+        return "critical";
+    if (values.includes("warning"))
+        return "warning";
+    return "ok";
+}

package/dist/core/model-defaults.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { piboHomePath } from "./pibo-home.js";
+import { isPiboThinkingLevel } from "./thinking.js";
+export const DEFAULT_PIBO_MODEL_DEFAULTS_PATH = "model-defaults.json";
+export function selectRequestedModelProfile(profile, defaults = {}) {
+    if (profile.model)
+        return cloneModelProfile(profile.model);
+    if (profile.parentSessionId)
+        return cloneModelProfile(profile.subagentModel ?? defaults.subagent);
+    return cloneModelProfile(profile.mainModel ?? defaults.main);
+}
+export function selectRequestedThinkingLevel(profile, defaults = {}) {
+    if (profile.parentSessionId)
+        return profile.subagentThinkingLevel ?? profile.thinkingLevel ?? defaults.subagentThinking ?? defaults.thinking;
+    return profile.mainThinkingLevel ?? profile.thinkingLevel ?? defaults.mainThinking ?? defaults.thinking;
+}
+export function selectRequestedFastMode(profile, defaults = {}) {
+    if (profile.parentSessionId)
+        return profile.subagentFast ?? profile.fast ?? defaults.subagentFast ?? defaults.fast;
+    return profile.mainFast ?? profile.fast ?? defaults.mainFast ?? defaults.fast;
+}
+export function loadPiboModelDefaults(cwd = process.cwd(), path) {
+    const resolvedPath = path ? resolve(cwd, path) : piboHomePath(DEFAULT_PIBO_MODEL_DEFAULTS_PATH);
+    if (!existsSync(resolvedPath))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+        return sanitizePiboModelDefaults(parsed);
+    }
+    catch {
+        return {};
+    }
+}
+export function savePiboModelDefaults(defaults, cwd = process.cwd(), path) {
+    const sanitized = sanitizePiboModelDefaults(defaults);
+    const resolvedPath = path ? resolve(cwd, path) : piboHomePath(DEFAULT_PIBO_MODEL_DEFAULTS_PATH);
+    mkdirSync(dirname(resolvedPath), { recursive: true });
+    writeFileSync(resolvedPath, `${JSON.stringify(sanitized, null, 2)}\n`);
+    return sanitized;
+}
+export function sanitizePiboModelDefaults(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const sanitized = {};
+    const main = sanitizeModelProfile(raw.main);
+    const subagent = sanitizeModelProfile(raw.subagent);
+    const thinking = sanitizeThinkingLevel(raw.thinking);
+    const mainThinking = sanitizeThinkingLevel(raw.mainThinking);
+    const subagentThinking = sanitizeThinkingLevel(raw.subagentThinking);
+    const fast = sanitizeBoolean(raw.fast);
+    const mainFast = sanitizeBoolean(raw.mainFast);
+    const subagentFast = sanitizeBoolean(raw.subagentFast);
+    if (main)
+        sanitized.main = main;
+    if (subagent)
+        sanitized.subagent = subagent;
+    if (thinking)
+        sanitized.thinking = thinking;
+    if (mainThinking)
+        sanitized.mainThinking = mainThinking;
+    if (subagentThinking)
+        sanitized.subagentThinking = subagentThinking;
+    if (fast !== undefined)
+        sanitized.fast = fast;
+    if (mainFast !== undefined)
+        sanitized.mainFast = mainFast;
+    if (subagentFast !== undefined)
+        sanitized.subagentFast = subagentFast;
+    return sanitized;
+}
+export function sanitizeThinkingLevel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return isPiboThinkingLevel(value) ? value : undefined;
+}
+export function sanitizeModelProfile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const raw = value;
+    if (typeof raw.provider !== "string" || typeof raw.id !== "string")
+        return undefined;
+    const provider = raw.provider.trim();
+    const id = raw.id.trim();
+    if (!provider || !id)
+        return undefined;
+    return { provider, id };
+}
+function cloneModelProfile(model) {
+    return model ? { ...model } : undefined;
+}
+function sanitizeBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}

package/dist/core/pibo-home.js

@@ -0,0 +1,8 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function getPiboHome() {
+    return process.env.PIBO_HOME || join(homedir(), ".pibo");
+}
+export function piboHomePath(...segments) {
+    return join(getPiboHome(), ...segments);
+}