@pasko70/pibo 1.13.0 → 1.14.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/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') {