@pasko70/pibo 1.13.0 → 1.15.0

package/dist/apps/context-files-ui/index.html

@@ -4,7 +4,7 @@
 		<meta charset="UTF-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<title>Pibo Context Files</title>
-		<script type="module" crossorigin src="/apps/context-files/assets/index-C7X2UvWe.js"></script>
+		<script type="module" crossorigin src="/apps/context-files/assets/index-DZWsbuvg.js"></script>
 		<link rel="modulepreload" crossorigin href="/apps/context-files/assets/dist-D1KyNDg5.js">
 		<link rel="stylesheet" crossorigin href="/apps/context-files/assets/index-Cs4XQITe.css">
 	</head>

package/dist/cli-session/localSessionSource.js

@@ -1050,6 +1050,8 @@ function executionParamsForSlash(command, args) {
     const trimmed = args?.trim();
     if (command === "compact" && trimmed)
         return { customInstructions: trimmed };
+    if (command === "goal")
+        return { command: trimmed ?? "" };
     if (command === "thinking" && trimmed)
         return { level: trimmed };
     if (command === "model" && trimmed) {

package/dist/core/runtime.js

@@ -25,6 +25,7 @@ import { registerOpenAiGpt56Models } from "../providers/openai-gpt56.js";
 import { PIBO_APP_CONTEXT } from "../app-context.js";
 import { createRuntimeToolDefinition } from "../tools/runtime/tool.js";
 import { RuntimeSessionRegistry } from "../tools/runtime/registry.js";
+import { CODEX_BROWSER_TOOL_NAMES, CodexBrowserSessionController, createCodexBrowserToolDefinitions, } from "../tools/codex-browser.js";
 import { compactValidationToolResultForContext } from "./test-output-compaction.js";
 import { installPiboTranscriptIntegrity } from "./transcript-integrity.js";
 function hasOwnRetrySetting(settings, key) {
@@ -102,12 +103,18 @@ function getEnabledSkillPaths(cwd, profile) {
         .filter((skill) => skill.enabled !== false)
         .map((skill) => resolveProfilePath(cwd, skill.path));
 }
-function getEnabledToolDefinitions(profile, options, subagentRunner, runToolController, runtimeToolController) {
+function getEnabledToolDefinitions(profile, options, subagentRunner, runToolController, runtimeToolController, codexBrowserController) {
     const runtimeProfileTool = profile.tools.find(isEnabledRuntimeTool);
     const runtimeTool = runtimeProfileTool && runtimeToolController
         ? createRuntimeToolDefinition(runtimeToolController)
         : undefined;
-    const profileTools = profile.tools.filter((tool) => !isRuntimeTool(tool)).filter(hasEnabledToolDefinition);
+    const selectedCodexBrowserToolNames = profile.tools
+        .filter(isEnabledCodexBrowserTool)
+        .map((tool) => tool.name);
+    const codexBrowserTools = codexBrowserController
+        ? createCodexBrowserToolDefinitions(codexBrowserController, selectedCodexBrowserToolNames)
+        : [];
+    const profileTools = profile.tools.filter((tool) => !isRuntimeTool(tool) && !isCodexBrowserTool(tool)).filter(hasEnabledToolDefinition);
     const profileToolDefinitions = profileTools.map((tool) => getToolDefinition(tool, options.toolContext));
     const codexCompatEnabled = profile.toolPackages.codexCompat === true;
     const runControlEnabled = profile.toolPackages.runControl === true;
@@ -129,6 +136,7 @@ function getEnabledToolDefinitions(profile, options, subagentRunner, runToolCont
         ...(runControlBashTool ? [runControlBashTool] : []),
         ...profileTools.filter((tool) => tool.yieldable !== false).map((tool) => getToolDefinition(tool, options.toolContext)),
         ...(runtimeTool && runtimeProfileTool?.yieldable !== false ? [runtimeTool] : []),
+        ...codexBrowserTools.filter((definition) => profile.tools.find((tool) => tool.name === definition.name)?.yieldable !== false),
         ...subagentTools,
         ...codexCompatTools,
     ];
@@ -139,6 +147,7 @@ function getEnabledToolDefinitions(profile, options, subagentRunner, runToolCont
         ...(runControlBashTool ? [runControlBashTool] : []),
         ...profileToolDefinitions,
         ...(runtimeTool ? [runtimeTool] : []),
+        ...codexBrowserTools,
         ...subagentTools,
         ...codexCompatTools,
         ...goalTools,
@@ -159,6 +168,12 @@ function isRuntimeTool(tool) {
 function isEnabledRuntimeTool(tool) {
     return tool.enabled !== false && isRuntimeTool(tool);
 }
+function isCodexBrowserTool(tool) {
+    return tool.builtInPiboTool === "codex_browser" || CODEX_BROWSER_TOOL_NAMES.includes(tool.name);
+}
+function isEnabledCodexBrowserTool(tool) {
+    return tool.enabled !== false && isCodexBrowserTool(tool);
+}
 function isGeneratedPiboTool(name) {
     return name === "runtime" || name.startsWith("pibo_subagent_") || name.startsWith("pibo_run_") || PIBO_GOAL_TOOL_NAMES.includes(name);
 }
@@ -280,6 +295,12 @@ export async function createPiboRuntime(options = {}) {
         const localRuntimeRegistry = ownsLocalRuntimeRegistry ? new RuntimeSessionRegistry({ cwd: runtimeCwd }) : undefined;
         const runtimeToolController = options.runtimeToolController
             ?? localRuntimeRegistry?.createController(profile.sessionId ?? "local");
+        const codexBrowserController = profile.tools.some(isEnabledCodexBrowserTool)
+            ? new CodexBrowserSessionController({
+                cwd: runtimeCwd,
+                piboSessionId: options.sessionContext?.piboSessionId ?? profile.sessionId ?? runtimeSessionManager.getSessionId(),
+            })
+            : undefined;
         const customTools = getEnabledToolDefinitions(profile, {
             runtimeCwd,
             shellCommandPrefix: services.settingsManager.getShellCommandPrefix(),
@@ -290,7 +311,7 @@ export async function createPiboRuntime(options = {}) {
                 profileName: profile.profileName,
                 getActiveMessage: options.sessionContext?.getActiveMessage,
             },
-        }, options.subagentRunner, options.runToolController, runtimeToolController);
+        }, options.subagentRunner, options.runToolController, runtimeToolController, codexBrowserController);
         const modelDefaults = options.modelDefaults ?? loadPiboModelDefaults(runtimeCwd);
         const created = await createAgentSessionFromServices({
             services,
@@ -324,6 +345,7 @@ export async function createPiboRuntime(options = {}) {
             if (localRuntimeRegistry) {
                 void localRuntimeRegistry.closeControllerSessions(profile.sessionId ?? "local", { force: true });
             }
+            void codexBrowserController?.dispose();
             originalDispose();
         };
         return {
@@ -444,8 +466,8 @@ export async function inspectPiboProfile(options = {}) {
             })),
             tools: profile.tools.map((tool) => ({
                 name: tool.name,
-                hasDefinition: Boolean(tool.definition) || Boolean(tool.createDefinition) || isRuntimeTool(tool),
-                registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined || isRuntimeTool(tool),
+                hasDefinition: Boolean(tool.definition) || Boolean(tool.createDefinition) || isRuntimeTool(tool) || isCodexBrowserTool(tool),
+                registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined || isRuntimeTool(tool) || isCodexBrowserTool(tool),
                 active: activeToolNames.has(tool.name) || tool.providerTool !== undefined,
             })).concat(generatedTools),
             subagents: profile.subagents.map((subagent) => {

package/dist/core/session-router.js

@@ -210,6 +210,9 @@ export class PiboSessionRouter {
                 recoveredRuns: this.runRegistry.listRecoveredRuns(),
             }) ?? []
             : [];
+        if (recoveredRuntimeState.length > 0 && options.runtimeInstanceId) {
+            console.error(`[pibo] authoritative runtime ${options.runtimeInstanceId} recovered ${recoveredRuntimeState.length} interrupted turn(s)`);
+        }
         for (const recovery of recoveredRuntimeState) {
             const session = this.sessionStore.get(recovery.event.piboSessionId);
             if (session)

package/dist/gateway/client.js

@@ -186,6 +186,14 @@ export async function runGatewayClient(options = {}) {
                 });
                 continue;
             }
+            if (text === "/goal" || text.startsWith("/goal ")) {
+                writeFrame(socket, {
+                    type: "req",
+                    id: randomUUID(),
+                    event: { type: "execution", piboSessionId, action: "goal", params: { command: text.slice("/goal".length).trim() } },
+                });
+                continue;
+            }
             writeFrame(socket, {
                 type: "req",
                 id: randomUUID(),

package/dist/gateway/server.js

@@ -1,9 +1,11 @@
+import { randomUUID } from "node:crypto";
 import { createServer } from "node:net";
 import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
 import { PiboSessionRouter } from "../core/session-router.js";
 import { createLoopMessagePreflight } from "../loops/store.js";
 import { loadPiboModelDefaults, selectRequestedModelProfile } from "../core/model-defaults.js";
 import { ResourceReaperService } from "../resources/reaper.js";
+import { InMemoryPiboSessionStore } from "../sessions/store.js";
 import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, errorResponse, isGatewayRequestFrame, isGatewaySubscribeFrame, } from "./protocol.js";
 import { releaseFallbackGatewayPid, releaseGatewayPid, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
 const DEFAULT_MAX_BACKPRESSURE_FRAMES = 1_000;
@@ -118,12 +120,15 @@ async function createGatewaySessionStore(options) {
         const { SqlitePiboSessionStore } = await import("../sessions/sqlite-store.js");
         return new SqlitePiboSessionStore(options.sessionDbPath);
     }
+    if (options.persistSession === false)
+        return new InMemoryPiboSessionStore();
     const { createDefaultPiboDataSessionStore } = await import("../sessions/pibo-data-store.js");
     return createDefaultPiboDataSessionStore();
 }
 export class PiboGatewayServer {
     options;
     pluginRegistry;
+    runtimeInstanceId;
     sessionStore;
     ownsSessionStore = false;
     router;
@@ -137,6 +142,7 @@ export class PiboGatewayServer {
     constructor(options = {}) {
         this.options = options;
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
+        this.runtimeInstanceId = options.runtimeInstanceId ?? `gateway:${process.pid}:${randomUUID()}`;
     }
     async start() {
         if (this.server)
@@ -144,12 +150,16 @@ export class PiboGatewayServer {
         this.validateChannels();
         this.sessionStore = this.options.sessionStore ?? (await createGatewaySessionStore(this.options));
         this.ownsSessionStore = !this.options.sessionStore;
+        const hasExplicitPersistentStore = this.options.sessionStore !== undefined || this.options.sessionDbPath !== undefined;
+        const recoverInterruptedRuntimeState = this.options.authoritativeRuntime === true
+            && (this.options.persistSession !== false || hasExplicitPersistentStore);
         this.router = new PiboSessionRouter({
             persistSession: this.options.persistSession,
             pluginRegistry: this.pluginRegistry,
             sessionStore: this.sessionStore,
             messagePreflight: createLoopMessagePreflight({ path: this.options.loopStorePath }),
-            recoverInterruptedRuntimeState: true,
+            recoverInterruptedRuntimeState,
+            runtimeInstanceId: recoverInterruptedRuntimeState ? this.runtimeInstanceId : undefined,
         });
         this.unsubscribe = this.router.subscribe((event) => this.broadcastRouterEvent(event));
         this.server = createServer((socket) => this.handleSocket(socket));
@@ -270,6 +280,8 @@ export class PiboGatewayServer {
     getDiagnostics() {
         const connectionDetails = [...this.connections].map((connection) => ({ ...connection.diagnostics }));
         return {
+            runtimeInstanceId: this.runtimeInstanceId,
+            authoritativeRuntime: this.options.authoritativeRuntime === true,
             connections: connectionDetails.length,
             slowConnections: connectionDetails.filter((connection) => connection.slow).length,
             droppedEvents: this.droppedRouterEvents,
@@ -377,7 +389,11 @@ export async function runGatewayServer(options = {}) {
     const releasePid = fallbackMode ? releaseFallbackGatewayPid : releaseGatewayPid;
     let server;
     try {
-        server = new PiboGatewayServer({ ...options, resourceReaper: resolveGatewayResourceReaperOptions(options) });
+        server = new PiboGatewayServer({
+            ...options,
+            authoritativeRuntime: options.authoritativeRuntime ?? true,
+            resourceReaper: resolveGatewayResourceReaperOptions(options),
+        });
         await server.start();
     }
     catch (error) {

package/dist/gateway/web.js

@@ -195,6 +195,7 @@ export async function runWebGatewayServer(options = {}) {
         const pluginRegistry = resolvedOptions.pluginRegistry ?? createWebPiboPluginRegistry(resolvedOptions);
         server = new PiboGatewayServer({
             ...resolvedOptions,
+            authoritativeRuntime: resolvedOptions.authoritativeRuntime ?? true,
             pluginRegistry,
             resourceReaper: resolveGatewayResourceReaperOptions(resolvedOptions),
             loopStorePath: resolvedOptions.chat?.ralphStorePath,

package/dist/local/extension.js

@@ -202,6 +202,8 @@ function createExecutionParams(slashCommand, args = "") {
     }
     if (slashCommand === "/compact")
         return trimmedArgs ? { customInstructions: trimmedArgs } : undefined;
+    if (slashCommand === "/goal")
+        return { command: trimmedArgs };
     return undefined;
 }
 function formatExecutionResult(event) {

package/dist/loops/plugin.js

@@ -1,7 +1,24 @@
 import { definePiboPlugin } from '../plugins/registry.js';
-import { createPiboLoopChannel } from './channel.js';
+import { createPiboLoopChannel, getPiboLoopService } from './channel.js';
 import { createBuiltInLoopStopConditions } from './stopping.js';
 import { configurePiboGoalToolStorePath } from './tools.js';
+function objectParams(event) {
+    const params = 'params' in event ? event.params : undefined;
+    return params && typeof params === 'object' && !Array.isArray(params) ? params : undefined;
+}
+export function parsePiboSessionGoalCommand(event) {
+    const command = objectParams(event)?.command;
+    if (typeof command !== 'string' || !command.trim())
+        throw new Error('Usage: /goal <objective> | /goal pause | /goal resume');
+    const normalized = command.trim();
+    if (normalized.toLowerCase() === 'pause')
+        return { operation: 'pause' };
+    if (normalized.toLowerCase() === 'resume')
+        return { operation: 'resume' };
+    if (normalized.length > 20_000)
+        throw new Error('Goal objective is too long');
+    return { operation: 'set', objective: normalized };
+}
 export function createPiboLoopPlugin(options = {}) {
     configurePiboGoalToolStorePath(options.loopStorePath);
     return definePiboPlugin({
@@ -10,6 +27,22 @@ export function createPiboLoopPlugin(options = {}) {
         register(api) {
             for (const condition of createBuiltInLoopStopConditions())
                 api.registerLoopStopCondition(condition);
+            api.registerGatewayAction({
+                name: 'goal',
+                description: 'Create or update the session Goal Loop. Use /goal pause or /goal resume to control it.',
+                slashCommands: ['goal'],
+                execute(context, event) {
+                    const service = getPiboLoopService();
+                    if (!service)
+                        throw new Error('Loop service is not running');
+                    const command = parsePiboSessionGoalCommand(event);
+                    if (command.operation === 'pause')
+                        return service.pauseSessionGoal(context.piboSessionId);
+                    if (command.operation === 'resume')
+                        return service.resumeSessionGoal(context.piboSessionId);
+                    return service.setSessionGoal(context.piboSessionId, command.objective);
+                },
+            });
             api.registerChannel(createPiboLoopChannel(options));
         },
     });

package/dist/loops/service.js

@@ -44,6 +44,8 @@ function failureRecovery(details) {
     return details?.retryable === false ? 'Resolve the reported non-retryable failure, then explicitly restart the Goal.' : 'Pibo will retry automatically after the recorded backoff.';
 }
 function isTerminalGoalStatus(status) { return status === 'complete' || status === 'blocked' || status === 'budget_limited'; }
+function currentGoalStatus(job) { return job.state.goalStatus ?? (job.enabled ? 'active' : 'paused'); }
+function goalName(objective) { return objective.replace(/\s+/g, ' ').trim().slice(0, 80); }
 function retryBackoffMs(consecutiveErrors, baseMs, maxMs, jitterRatio, random) {
     const exponent = Math.max(0, Math.min(30, consecutiveErrors - 1));
     const bounded = Math.min(maxMs, baseMs * (2 ** exponent));
@@ -145,6 +147,89 @@ export class PiboLoopService {
         this.armSoon();
         return this.store.getJob(id);
     }
+    setSessionGoal(piboSessionId, objective) {
+        const normalizedObjective = objective.trim();
+        if (!normalizedObjective)
+            throw new Error('Usage: /goal <objective> | /goal pause | /goal resume');
+        if (normalizedObjective.length > 20_000)
+            throw new Error('Goal objective is too long');
+        const session = this.options.context.getSession(piboSessionId);
+        if (!session)
+            throw new Error('Pibo Session not found');
+        const existing = this.store.getSessionGoalOwner(piboSessionId);
+        if (!existing) {
+            const goal = this.store.createSessionGoal({
+                name: goalName(normalizedObjective),
+                target: this.sessionGoalTarget(session.metadata?.chatRoomId),
+                profile: session.profile,
+                prompt: normalizedObjective,
+                initialPiboSessionId: piboSessionId,
+            }, this.now());
+            this.armSoon();
+            return { operation: 'created', goal };
+        }
+        const status = currentGoalStatus(existing);
+        if (status === 'complete')
+            throw new Error('The current Goal is completing; wait for its active run to finish before creating another Goal');
+        if (status === 'blocked')
+            throw new Error('The current Goal is blocked; explicitly reopen it before updating or resuming it');
+        if (status === 'budget_limited')
+            throw new Error('The current Goal is budget limited; increase or clear its token budget before updating and resuming it');
+        const goal = this.store.updateJob(existing.id, {
+            name: goalName(normalizedObjective),
+            prompt: normalizedObjective,
+            enabled: true,
+        }, this.now());
+        if (!goal)
+            throw new Error('Goal Loop not found');
+        this.armSoon();
+        return { operation: 'updated', goal };
+    }
+    pauseSessionGoal(piboSessionId) {
+        const existing = this.requireSessionGoal(piboSessionId);
+        const status = currentGoalStatus(existing);
+        if (status === 'paused')
+            return { operation: 'already-paused', goal: existing };
+        if (status !== 'active')
+            throw new Error(`Goal Loop cannot be paused while its status is ${status}`);
+        const goal = this.store.requestStop(existing.id, this.now());
+        if (!goal)
+            throw new Error('Goal Loop not found');
+        this.armSoon();
+        return { operation: 'paused', goal };
+    }
+    resumeSessionGoal(piboSessionId) {
+        const existing = this.requireSessionGoal(piboSessionId);
+        const status = currentGoalStatus(existing);
+        if (status === 'active' && existing.enabled)
+            return { operation: 'already-active', goal: existing };
+        if (status !== 'paused')
+            throw new Error(`Goal Loop cannot be resumed while its status is ${status}`);
+        const goal = this.store.updateJob(existing.id, { enabled: true }, this.now());
+        if (!goal)
+            throw new Error('Goal Loop not found');
+        this.armSoon();
+        return { operation: 'resumed', goal };
+    }
+    requireSessionGoal(piboSessionId) {
+        if (!this.options.context.getSession(piboSessionId))
+            throw new Error('Pibo Session not found');
+        const goal = this.store.getSessionGoalOwner(piboSessionId);
+        if (!goal)
+            throw new Error('This Pibo Session has no Goal Loop');
+        return goal;
+    }
+    sessionGoalTarget(value) {
+        if (typeof value !== 'string' || !value.trim())
+            return { kind: 'default-chat' };
+        const roomId = value.trim();
+        const room = this.roomService.getRoom(roomId);
+        if (!room)
+            throw new Error('The Pibo Session room no longer exists');
+        if (isPiboRoomArchived(room))
+            throw new Error('Archived rooms are read-only');
+        return { kind: 'room', roomId };
+    }
     repairGoalSessionMetadata() {
         for (const session of this.options.context.listSessions?.() ?? []) {
             if (session.metadata?.loopMode === 'goal' && (session.metadata.loopJobId !== undefined || session.metadata.loopRunId !== undefined))

package/dist/mcp/config-command.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { ensureConfigExists, findConfigPath, getPreferredConfigPath, } from './config.js';
 import { ErrorCode, formatCliError } from './errors.js';
@@ -155,9 +156,10 @@ export async function configCommand(options) {
         return;
     }
     if (options.action === 'init') {
-        const existingPath = findConfigPath(options.configPath);
-        const path = await ensureConfigExists(options.configPath);
-        console.log(existingPath ? `MCP config ready: ${path}` : `Created MCP config: ${path}`);
+        const preferredPath = getPreferredConfigPath(options.configPath);
+        const alreadyExists = existsSync(preferredPath);
+        const path = await ensureConfigExists(preferredPath);
+        console.log(alreadyExists ? `MCP config ready: ${path}` : `Created MCP config: ${path}`);
         return;
     }
     if (options.action === 'describe') {

package/dist/plugins/builtin.js

@@ -4,6 +4,7 @@ import { createPiboGatewayToolProfiles } from "../gateway/tool.js";
 import { InitialSessionContextBuilder } from "../core/profiles.js";
 import { parsePiboThinkingLevel } from "../core/thinking.js";
 import { createWebSearchToolProfile } from "../tools/web-search.js";
+import { CODEX_BROWSER_TOOL_NAMES, createCodexBrowserToolProfiles } from "../tools/codex-browser.js";
 import { createRuntimeToolProfile } from "../tools/runtime/tool.js";
 import { completeLogin, getLoginStatus, removeLogin, setApiKey, startLogin } from "../auth/login-actions.js";
 import { loadModelCatalog } from "../apps/chat/model-catalog.js";
@@ -166,6 +167,12 @@ export const piboCorePlugin = definePiboPlugin({
         });
         api.registerTool(createWebSearchToolProfile());
         api.registerTool(createRuntimeToolProfile());
+        api.registerTools(createCodexBrowserToolProfiles());
+        api.registerCapabilityPackage({
+            name: "codex-browser-interface",
+            description: "Expose Browser Use and its persistent browser-bound Node REPL through a Codex-familiar structured tool surface.",
+            toolNames: [...CODEX_BROWSER_TOOL_NAMES],
+        });
         registerPiboNativeTooling(api);
         api.registerProfile({
             name: DEFAULT_PIBO_PROFILE_NAME,