@pasko70/pibo 3.2.2 → 3.2.4

package/dist/core/session-router.js

@@ -1196,7 +1196,7 @@ export class PiboSessionRouter {
         const status = current.getStatus();
         if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0)
             return;
-        await this.resetCachedSession(piboSessionId, "routed runtime idle timeout");
+        await this.resetCachedSession(piboSessionId);
     }
     async getOrCreateSession(piboSessionId) {
         if (this.closing)
@@ -1391,6 +1391,7 @@ export class PiboSessionRouter {
                     ...(runtimeBindingPersistence ? { runtimeBindingPersistence } : {}),
                     compatibility: {
                         persistSession: this.options.persistSession,
+                        piPackageStoreCwd: this.options.piPackageStoreCwd,
                         thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
                         retryDefaults: resolvePiboSessionRetryDefaults(piboSession.kind, this.options.retryDefaults),
                         extensionFactories: [
@@ -2015,6 +2016,8 @@ export class PiboSessionRouter {
                     resolveSettled = resolve;
                 });
                 const untrack = this.trackActiveSubagent(parentPiboSessionId, {
+                    agentId: child.id,
+                    requestId,
                     abortController: parentAbortController,
                     settled,
                 });
@@ -2098,8 +2101,14 @@ export class PiboSessionRouter {
         const child = this.requireManagedAgent(parentPiboSessionId, agentId);
         const ids = [agentId, ...this.descendantSessionIds(agentId)];
         const idSet = new Set(ids);
+        const activeParentRunIds = new Set([...(this.activeSubagentRequests.get(parentPiboSessionId) ?? [])]
+            .filter((request) => idSet.has(request.agentId))
+            .map((request) => request.requestId));
         const cancellableRuns = this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })
-            .filter((run) => idSet.has(run.controllerPiboSessionId) && !isTerminalRunStatus(run.status));
+            .filter((run) => !isTerminalRunStatus(run.status) && (idSet.has(run.controllerPiboSessionId)
+            || (run.controllerPiboSessionId === parentPiboSessionId && activeParentRunIds.has(run.runId))));
+        const reason = `killed by parent ${parentPiboSessionId}`;
+        await this.cancelRunsAfterSettlement(cancellableRuns.filter((run) => run.controllerPiboSessionId === parentPiboSessionId), reason);
         await Promise.allSettled(ids.flatMap((id) => this.sessions.has(id)
             ? [this.emit({ type: "execution", piboSessionId: id, action: "abort", id: randomUUID() })]
             : []));
@@ -2112,7 +2121,7 @@ export class PiboSessionRouter {
                 },
             });
         }
-        await this.disposeSessionSubtree(agentId, `killed by parent ${parentPiboSessionId}`, { cancelRuns: true });
+        await this.disposeSessionSubtree(agentId, reason, { cancelRuns: true });
         const cancelledRuns = cancellableRuns.flatMap((run) => {
             const current = this.runRegistry.status(run.controllerPiboSessionId, run.runId);
             return current.status === "cancelled" ? [run.runId] : [];
@@ -2368,9 +2377,11 @@ export class PiboSessionRouter {
             : eventId
                 ? this.subagentRequestIdsByEvent.get(subagentRequestEventKey(session.id, eventId))
                 : undefined;
+        const sequence = this.sessionStore.claimAgentObservationSequence?.(session.parentId, this.nextAgentObservationSequence) ?? this.nextAgentObservationSequence;
+        this.nextAgentObservationSequence = Math.max(this.nextAgentObservationSequence, sequence + 1);
         const observation = {
             managingParentId: session.parentId,
-            sequence: this.nextAgentObservationSequence++,
+            sequence,
             createdAt: new Date().toISOString(),
             ...(requestId ? { requestId } : {}),
             agentId: session.id,

package/dist/cron/cli.js

@@ -34,18 +34,44 @@ function maybeTargetFromOptions(options) {
         return undefined;
     return targetFromOptions(options);
 }
+function scheduleSelectors(options, positionalCron) {
+    const candidates = [
+        ["--in", typeof options.in === "string"],
+        ["--at", typeof options.at === "string"],
+        ["--every", typeof options.every === "string"],
+        ["--daily", typeof options.daily === "string"],
+        ["--weekly", typeof options.weekly === "string"],
+        ["--monthly", typeof options.monthly === "string" || typeof options.monthly === "number"],
+        ["--cron", typeof options.cron === "string"],
+        ["positional cron expression", Boolean(positionalCron)],
+    ];
+    return candidates.filter(([, selected]) => selected).map(([selector]) => selector);
+}
 function hasScheduleOptions(options, positionalCron) {
-    return Boolean(positionalCron ||
-        typeof options.in === "string" ||
-        typeof options.at === "string" ||
-        typeof options.every === "string" ||
-        typeof options.daily === "string" ||
-        typeof options.weekly === "string" ||
-        typeof options.monthly === "string" ||
-        typeof options.monthly === "number" ||
-        typeof options.cron === "string");
+    return scheduleSelectors(options, positionalCron).length > 0;
+}
+function scheduleWithTimezone(job, tz) {
+    if (job.schedule.kind !== "cron")
+        throw new Error("--tz can only update an existing wall-clock cron schedule");
+    let scheduleUi;
+    if (job.scheduleUi) {
+        switch (job.scheduleUi.preset) {
+            case "daily":
+            case "weekly":
+            case "monthly":
+            case "advanced":
+                scheduleUi = { ...job.scheduleUi, tz };
+                break;
+            default:
+                scheduleUi = job.scheduleUi;
+        }
+    }
+    return { schedule: { ...job.schedule, tz }, scheduleUi };
 }
 function scheduleFromOptions(options, positionalCron) {
+    const selectors = scheduleSelectors(options, positionalCron);
+    if (selectors.length > 1)
+        throw new Error(`Conflicting schedule selectors: ${selectors.join(", ")}. Choose exactly one schedule source.`);
     if (typeof options.in === "string")
         return parseFriendlySchedule({ kind: "in", value: options.in });
     if (typeof options.at === "string")
@@ -169,7 +195,13 @@ export async function runCronCli(argv = process.argv) {
         .action((id, cronExprParts, options) => {
         const store = createDefaultPiboCronStore({ path: program.opts().store });
         const positionalCron = Array.isArray(cronExprParts) && cronExprParts.length ? cronExprParts.join(" ") : undefined;
-        const normalized = hasScheduleOptions(options, positionalCron) ? scheduleFromOptions(options, positionalCron) : undefined;
+        let normalized = hasScheduleOptions(options, positionalCron) ? scheduleFromOptions(options, positionalCron) : undefined;
+        if (!normalized && typeof options.tz === "string") {
+            const existing = store.getJob(id);
+            if (!existing)
+                throw new Error("Cron job not found");
+            normalized = scheduleWithTimezone(existing, options.tz);
+        }
         const target = maybeTargetFromOptions(options);
         const patch = {
             ...(options.name !== undefined ? { name: options.name } : {}),

package/dist/cron/store.js

@@ -144,7 +144,7 @@ export class PiboCronStore {
             runningAt: existing.state.runningAt,
             nextRunAt: next.enabled ? computeNextRunAt(next.schedule, now)?.toISOString() : undefined,
         };
-        if (next.enabled && !next.state.nextRunAt && next.schedule.kind !== "at")
+        if (next.enabled && !next.state.nextRunAt)
             throw new Error("schedule has no future run");
         this.writeJob(next);
         return this.getJob(id);

package/dist/data/cli.js

@@ -86,15 +86,19 @@ function migrateSessionsToV2(input) {
     if (!report.inputExists)
         return report;
     const source = new DatabaseSync(input.from, { readOnly: true });
-    const target = new PiboDataStore(input.to);
+    let target;
     try {
-        if (!hasTable(source, "pibo_sessions"))
-            return report;
+        if (!hasTable(source, "pibo_sessions")) {
+            throw new Error(`Cannot migrate sessions from "${input.from}": required legacy table "pibo_sessions" is missing.`);
+        }
+        target = new PiboDataStore(input.to);
         const rows = source.prepare("SELECT * FROM pibo_sessions ORDER BY created_at ASC").all();
         report.read = rows.length;
         for (const row of rows) {
             const existing = target.db.prepare("SELECT updated_at FROM sessions WHERE id = ?").get(row.id);
             const metadata = parseJsonObject(row.metadata_json);
+            let migrateBinding = false;
+            const roomId = typeof metadata.chatRoomId === "string" ? metadata.chatRoomId : null;
             const rootSessionId = row.parent_id ? (typeof metadata.rootSessionId === "string" ? metadata.rootSessionId : row.parent_id) : row.id;
             if (!existing) {
                 const columns = [
@@ -105,22 +109,26 @@ function migrateSessionsToV2(input) {
                 target.db.prepare(`
 					INSERT INTO sessions (${columns.join(", ")})
 					VALUES (${columns.map(() => "?").join(", ")})
-				`).run(row.id, row.pi_session_id, typeof metadata.chatRoomId === "string" ? metadata.chatRoomId : null, rootSessionId, row.parent_id, row.origin_id, row.channel, row.kind, row.profile, row.active_model_json, row.workspace, row.title ?? "Untitled Session", "idle", JSON.stringify(metadata), row.created_at, row.updated_at, row.updated_at);
+				`).run(row.id, row.pi_session_id, roomId, rootSessionId, row.parent_id, row.origin_id, row.channel, row.kind, row.profile, row.active_model_json, row.workspace, row.title ?? "Untitled Session", "idle", JSON.stringify(metadata), row.created_at, row.updated_at, row.updated_at);
                 report.inserted++;
+                migrateBinding = true;
             }
             else if (row.updated_at > existing.updated_at) {
                 target.db.prepare(`
 					UPDATE sessions SET
-						pi_session_id = ?, root_session_id = ?, parent_id = ?, origin_id = ?,
+						pi_session_id = ?, room_id = ?, root_session_id = ?, parent_id = ?, origin_id = ?,
 						channel = ?, kind = ?, profile = ?, active_model_json = ?, workspace = ?, title = ?,
 						metadata_json = ?, updated_at = ?, last_activity_at = MAX(last_activity_at, ?)
 					WHERE id = ?
-				`).run(row.pi_session_id, rootSessionId, row.parent_id, row.origin_id, row.channel, row.kind, row.profile, row.active_model_json, row.workspace, row.title ?? "Untitled Session", JSON.stringify(metadata), row.updated_at, row.updated_at, row.id);
+				`).run(row.pi_session_id, roomId, rootSessionId, row.parent_id, row.origin_id, row.channel, row.kind, row.profile, row.active_model_json, row.workspace, row.title ?? "Untitled Session", JSON.stringify(metadata), row.updated_at, row.updated_at, row.id);
                 report.updated++;
+                migrateBinding = true;
             }
             else {
                 report.skipped++;
             }
+            if (!migrateBinding)
+                continue;
             target.db.prepare(`
 				INSERT INTO session_runtime_bindings (
 					pibo_session_id, runtime_instance_id, runtime_adapter_id, native_session_id,
@@ -142,7 +150,7 @@ function migrateSessionsToV2(input) {
     }
     finally {
         source.close();
-        target.close();
+        target?.close();
     }
     return report;
 }

package/dist/data/payload-store.js

@@ -4,6 +4,22 @@ import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, re
 import { dirname, extname, join, resolve } from "node:path";
 import { piboHomePath } from "../core/pibo-home.js";
 const MAX_SYNC_PAYLOAD_GZIP_BYTES = 512 * 1024;
+export class PiboPayloadMetadataConflictError extends Error {
+    sha256;
+    existingContentType;
+    requestedContentType;
+    existingRetentionClass;
+    requestedRetentionClass;
+    constructor(sha256, existingContentType, requestedContentType, existingRetentionClass, requestedRetentionClass) {
+        super(`Payload bytes already exist with incompatible metadata: content type ${existingContentType} vs ${requestedContentType}; retention class ${existingRetentionClass} vs ${requestedRetentionClass}`);
+        this.sha256 = sha256;
+        this.existingContentType = existingContentType;
+        this.requestedContentType = requestedContentType;
+        this.existingRetentionClass = existingRetentionClass;
+        this.requestedRetentionClass = requestedRetentionClass;
+        this.name = "PiboPayloadMetadataConflictError";
+    }
+}
 export class PayloadStore {
     db;
     rootDir;
@@ -20,6 +36,9 @@ export class PayloadStore {
         const sha256 = createHash("sha256").update(bytes).digest("hex");
         const existing = this.findBySha256(sha256);
         if (existing) {
+            if (existing.contentType !== contentType || existing.retentionClass !== input.retentionClass) {
+                throw new PiboPayloadMetadataConflictError(sha256, existing.contentType, contentType, existing.retentionClass, input.retentionClass);
+            }
             this.db.prepare("UPDATE payloads SET ref_count = ref_count + 1 WHERE id = ?").run(existing.id);
             return this.getPayload(existing.id) ?? existing;
         }
@@ -111,6 +130,25 @@ export class PayloadStore {
         const row = this.db.prepare("SELECT * FROM payloads WHERE sha256 = ?").get(sha256);
         return row ? payloadFromRow(row) : undefined;
     }
+    releaseReferences(id, count = 1) {
+        if (!Number.isSafeInteger(count) || count < 1)
+            throw new RangeError("count must be a positive safe integer");
+        const row = this.db.prepare("SELECT * FROM payloads WHERE id = ?").get(id);
+        if (!row)
+            return undefined;
+        if (row.ref_count > count) {
+            this.db.prepare("UPDATE payloads SET ref_count = ref_count - ? WHERE id = ?").run(count, id);
+            return undefined;
+        }
+        this.db.prepare("DELETE FROM payloads WHERE id = ?").run(id);
+        return payloadFromRow(row);
+    }
+    removeReleasedFile(payload) {
+        if (payload.storageKind !== "file" || !payload.storagePath)
+            return;
+        const absolutePath = this.rootDir === ":memory:" ? payload.storagePath : join(this.rootDir, payload.storagePath);
+        rmSync(absolutePath, { force: true });
+    }
 }
 function readFileBounded(path, maxBytes) {
     const descriptor = openSync(path, "r");

package/dist/data/schema.js

@@ -1,4 +1,5 @@
 export const PIBO_DATA_SCHEMA_VERSION = 7;
+const NATIVE_HISTORY_FALLBACK_SCHEMA_VERSION = 5;
 const retiredScopeColumn = ["owner", "scope"].join("_");
 const retiredScopeTables = [
     {
@@ -199,6 +200,13 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
 			FOREIGN KEY (pibo_session_id) REFERENCES sessions(id) ON DELETE CASCADE
 		);
 
+		CREATE TABLE IF NOT EXISTS session_agent_observation_counters (
+			parent_pibo_session_id TEXT PRIMARY KEY,
+			next_sequence INTEGER NOT NULL CHECK(next_sequence >= 1),
+			updated_at TEXT NOT NULL,
+			FOREIGN KEY (parent_pibo_session_id) REFERENCES sessions(id) ON DELETE CASCADE
+		);
+
 		CREATE TABLE IF NOT EXISTS session_output_part_counters (
 			pibo_session_id TEXT NOT NULL,
 			event_id TEXT NOT NULL,
@@ -784,7 +792,7 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
     hooks.afterStep?.("sequence-repair-backfill");
     db.exec("DROP TABLE pibo_v7_sequence_repair_sessions");
     hooks.afterStep?.("sequence-repair-cleanup");
-    if (previousVersion < PIBO_DATA_SCHEMA_VERSION && hadSessionsBeforeMigration) {
+    if (previousVersion < NATIVE_HISTORY_FALLBACK_SCHEMA_VERSION && hadSessionsBeforeMigration) {
         const rows = db.prepare("SELECT pibo_session_id, metadata_json FROM session_runtime_bindings").all();
         const update = db.prepare("UPDATE session_runtime_bindings SET metadata_json = ? WHERE pibo_session_id = ?");
         for (const row of rows) {

package/dist/debug/index.js

@@ -322,6 +322,11 @@ async function runDebugDb(args) {
     const command = args[0];
     const options = parseOptions(args.slice(1));
     if (command === "stores") {
+        const unknownOption = options.positionals.find((value) => value.startsWith("-"));
+        if (unknownOption)
+            throw new Error(`Unknown option "${unknownOption}" for pibo debug db stores. Run pibo debug db --help.`);
+        if (options.positionals.length > 0)
+            throw new Error("pibo debug db stores accepts no positional arguments. Run pibo debug db --help.");
         const stores = resolveDebugStores();
         if (options.json) {
             console.log(JSON.stringify({ stores }, null, 2));

package/dist/debug/pty.js

@@ -96,6 +96,26 @@ if exit_code is None:
     exit_code = proc.wait(timeout=1)
 sys.exit(exit_code if exit_code is not None else 1)
 `;
+const PTY_SCENARIO_FIELDS = new Set([
+    "name",
+    "command",
+    "cwd",
+    "workdir",
+    "env",
+    "rows",
+    "cols",
+    "timeoutMs",
+    "idleTimeoutMs",
+    "inputDelayMs",
+    "providerMode",
+    "maxIterations",
+    "artifactDir",
+    "artifact",
+    "steps",
+    "expect",
+    "reject",
+    "stopPatterns",
+]);
 class WallClockTimeoutError extends Error {
     constructor(timeoutMs) {
         super(`PTY command timed out after ${timeoutMs}ms`);
@@ -234,17 +254,17 @@ function parsePtyOptions(args) {
         else if (arg === "--env")
             options.env.push(requireOptionValue(args, ++index, arg));
         else if (arg === "--expect")
-            options.expect.push(requireOptionValue(args, ++index, arg));
+            options.expect.push(requireTextOptionValue(args, ++index, arg));
         else if (arg === "--reject")
-            options.reject.push(requireOptionValue(args, ++index, arg));
+            options.reject.push(requireTextOptionValue(args, ++index, arg));
         else if (arg === "--stop-pattern")
-            options.stopPatterns.push(requireOptionValue(args, ++index, arg));
+            options.stopPatterns.push(requireTextOptionValue(args, ++index, arg));
         else if (arg === "--type")
-            options.steps.push({ typeText: requireOptionValue(args, ++index, arg) });
+            options.steps.push({ typeText: requireTextOptionValue(args, ++index, arg) });
         else if (arg === "--press")
             options.steps.push({ press: requireOptionValue(args, ++index, arg) });
         else if (arg === "--wait-for")
-            options.steps.push({ waitFor: requireOptionValue(args, ++index, arg) });
+            options.steps.push({ waitFor: requireTextOptionValue(args, ++index, arg) });
         else if (arg === "--sleep-ms")
             options.steps.push({ sleepMs: parseNonNegativeInteger(requireOptionValue(args, ++index, arg), arg) });
         else if (arg === "--builtin")
@@ -269,6 +289,12 @@ function requireOptionValue(args, index, option) {
         throw new Error(`${option} requires a value`);
     return value;
 }
+function requireTextOptionValue(args, index, option) {
+    const value = args[index];
+    if (value === undefined)
+        throw new Error(`${option} requires a value`);
+    return value;
+}
 function scenarioFromRunOptions(options) {
     return {
         name: options.name ?? "adhoc-run",
@@ -363,6 +389,10 @@ function validateScenario(value, source) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error(`${source}: scenario must be an object`);
     const raw = value;
+    for (const field of Object.keys(raw)) {
+        if (!PTY_SCENARIO_FIELDS.has(field))
+            throw new Error(`${source}: unknown field "${field}"`);
+    }
     if (!Array.isArray(raw.command) || raw.command.some((item) => typeof item !== "string") || raw.command.length === 0) {
         throw new Error(`${source}: command must be a non-empty string array`);
     }
@@ -425,6 +455,7 @@ async function executePtyScenario(input, options) {
     let stopReason = "completed";
     let exitCode = null;
     let signal = null;
+    const waitCursor = { cleanOffset: 0 };
     try {
         validateProviderSafety(scenario, options);
         runner = await startRunner(scenario);
@@ -449,7 +480,7 @@ async function executePtyScenario(input, options) {
                 }
             }
             await checkIdle(runner, refreshOutputTimestamp, scenario.idleTimeoutMs);
-            await runStep(runner, scenario, step, assertions, refreshOutputTimestamp, deadline);
+            await runStep(runner, scenario, step, assertions, refreshOutputTimestamp, deadline, waitCursor);
             throwIfDeadlineExpired(deadline);
             refreshOutputTimestamp();
             const clean = cleanTerminalText(runner.getRawOutput());
@@ -667,9 +698,9 @@ function wrapChild(child, backend, ptyMethod) {
         getEvents: () => events,
     };
 }
-async function runStep(runner, scenario, step, assertions, markOutput, deadline) {
+async function runStep(runner, scenario, step, assertions, markOutput, deadline, waitCursor) {
     if (step.waitFor !== undefined) {
-        await waitForText(runner, step.waitFor, step.timeoutMs ?? scenario.timeoutMs, scenario.idleTimeoutMs, markOutput, deadline);
+        await waitForText(runner, step.waitFor, step.timeoutMs ?? scenario.timeoutMs, scenario.idleTimeoutMs, markOutput, deadline, waitCursor);
         return;
     }
     if (step.typeText !== undefined) {
@@ -706,13 +737,17 @@ async function runStep(runner, scenario, step, assertions, markOutput, deadline)
     if (step.reject !== undefined)
         assertPatterns(clean, [], [step.reject], assertions);
 }
-async function waitForText(runner, pattern, timeoutMs, idleTimeoutMs, markOutput, globalDeadline) {
+async function waitForText(runner, pattern, timeoutMs, idleTimeoutMs, markOutput, globalDeadline, cursor) {
     const stepDeadline = performance.now() + timeoutMs;
     while (true) {
         throwIfDeadlineExpired(globalDeadline);
         const lastOutputAt = markOutput();
-        if (cleanTerminalText(runner.getRawOutput()).includes(pattern))
+        const clean = cleanTerminalText(runner.getRawOutput());
+        const matchIndex = clean.indexOf(pattern, Math.min(cursor.cleanOffset, clean.length));
+        if (matchIndex >= 0) {
+            cursor.cleanOffset = matchIndex + pattern.length;
             return;
+        }
         const now = performance.now();
         if (now - lastOutputAt > idleTimeoutMs) {
             await runner.terminate("idle_timeout");

package/dist/gateway/cli.js

@@ -52,7 +52,19 @@ function expectedMode(target) {
 }
 function gatewayServiceName(target) {
     const fromEnv = target === "web" ? process.env.PIBO_GATEWAY_WEB_SERVICE : process.env.PIBO_GATEWAY_DEV_SERVICE;
-    return fromEnv || (target === "web" ? "pibo-web" : "pibo-web-dev");
+    if (fromEnv)
+        return fromEnv;
+    if (target === "web") {
+        try {
+            const persisted = readFileSync(join(managedGatewayHome(target), "gateway-web-service"), "utf8").trim();
+            if (/^[A-Za-z0-9_.@-]+$/.test(persisted))
+                return persisted;
+        }
+        catch {
+            // Fall back to the default service name when setup has not persisted an override.
+        }
+    }
+    return target === "web" ? "pibo-web" : "pibo-web-dev";
 }
 function gatewayManagerCommand() {
     return process.env.PIBO_GATEWAY_MANAGER_COMMAND || "systemctl";
@@ -62,7 +74,11 @@ function shouldUseWindowsGatewayManager() {
 }
 function managedGatewayHome(target) {
     const fromEnv = target === "web" ? process.env.PIBO_GATEWAY_WEB_HOME : process.env.PIBO_GATEWAY_DEV_HOME;
-    return fromEnv || join(homedir(), target === "web" ? ".pibo" : ".pibo-dev");
+    if (fromEnv)
+        return fromEnv;
+    if (target === "web" && process.env.PIBO_HOME)
+        return process.env.PIBO_HOME;
+    return join(homedir(), target === "web" ? ".pibo" : ".pibo-dev");
 }
 function targetGatewayPort(target) {
     const fromEnv = target === "web" ? process.env.PIBO_GATEWAY_WEB_AGENT_PORT : process.env.PIBO_GATEWAY_DEV_AGENT_PORT;

package/dist/gateway/server.js

@@ -159,6 +159,7 @@ export class PiboGatewayServer {
             && (this.options.persistSession !== false || hasExplicitPersistentStore);
         this.router = new PiboSessionRouter({
             persistSession: this.options.persistSession,
+            piPackageStoreCwd: this.options.piPackageStoreCwd ?? process.cwd(),
             pluginRegistry: this.pluginRegistry,
             sessionStore: this.sessionStore,
             messagePreflight: createLoopMessagePreflight({ path: this.options.loopStorePath }),

package/dist/loops/service.js

@@ -20,6 +20,9 @@ class LoopRunTimeoutError extends Error {
         this.name = 'LoopRunTimeoutError';
     }
 }
+export class PiboLoopCapacityError extends Error {
+    constructor() { super('Loop run capacity is currently full'); this.name = 'PiboLoopCapacityError'; }
+}
 class LoopContinuationInvalidatedError extends Error {
     constructor(message) { super(message); this.name = 'LoopContinuationInvalidatedError'; }
 }
@@ -84,6 +87,7 @@ export class PiboLoopService {
     random;
     timer;
     activeRuns = 0;
+    admissionTail = Promise.resolve();
     activeRunWork = new Set();
     pendingRunStarts = 0;
     schedulerWork;
@@ -143,14 +147,21 @@ export class PiboLoopService {
             return undefined;
         this.pendingRunStarts += 1;
         try {
-            const job = this.store.updateJob(id, { enabled: true });
-            if (!job)
-                return undefined;
-            const reserved = await this.reserveAfterBeforeRunEvaluation(job);
-            if (!reserved)
-                return undefined;
-            this.launchReservedRun(reserved.job, reserved.run);
-            return reserved.run;
+            return await this.withAdmissionLock(async () => {
+                const existing = this.store.getJob(id);
+                if (!existing || existing.state.runningAt)
+                    return undefined;
+                if (this.activeRuns >= this.maxConcurrentRuns)
+                    throw new PiboLoopCapacityError();
+                const job = this.store.updateJob(id, { enabled: true });
+                if (!job)
+                    return undefined;
+                const reserved = await this.reserveAfterBeforeRunEvaluation(job);
+                if (!reserved)
+                    return undefined;
+                this.launchReservedRun(reserved.job, reserved.run);
+                return reserved.run;
+            });
         }
         finally {
             this.pendingRunStarts -= 1;
@@ -303,14 +314,13 @@ export class PiboLoopService {
     async tick() { if (this.stopped)
         return; try {
         await this.abortCancelRequestedJobs();
-        const capacity = this.maxConcurrentRuns - this.activeRuns;
-        if (capacity > 0) {
-            const jobs = this.store.listJobs({ includeDisabled: false }).filter((job) => !job.state.runningAt).slice(0, capacity);
-            for (const job of jobs) {
-                const reserved = await this.reserveAfterBeforeRunEvaluation(job);
-                if (reserved)
-                    this.launchReservedRun(reserved.job, reserved.run);
-            }
+        const jobs = this.store.listJobs({ includeDisabled: false }).filter((job) => !job.state.runningAt);
+        for (const job of jobs) {
+            const admitted = await this.withAdmissionLock(async () => { if (this.activeRuns >= this.maxConcurrentRuns)
+                return false; const reserved = await this.reserveAfterBeforeRunEvaluation(job); if (!reserved)
+                return true; this.launchReservedRun(reserved.job, reserved.run); return true; });
+            if (!admitted)
+                break;
         }
     }
     catch (error) {
@@ -319,6 +329,12 @@ export class PiboLoopService {
     finally {
         this.arm();
     } }
+    async withAdmissionLock(action) { const previous = this.admissionTail; let release; this.admissionTail = new Promise((resolve) => { release = resolve; }); await previous; try {
+        return await action();
+    }
+    finally {
+        release();
+    } }
     async reserveAfterBeforeRunEvaluation(job) {
         const fresh = this.store.getJob(job.id) ?? job;
         const now = this.now();

package/dist/mcp/runtime-session.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { redactSensitiveText } from "../core/sensitive-data-redaction.js";
 import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { filterTools, isHttpServer, } from "./config.js";
@@ -94,7 +95,7 @@ export function redactMcpRuntimeError(error, secretValues = []) {
         if (value)
             message = message.split(value).join("[REDACTED]");
     }
-    return message.replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]");
+    return redactSensitiveText(message).replaceAll("[redacted]", "[REDACTED]");
 }
 export async function verifyPiboMcpServer(serverName, config, options) {
     const client = new Client({ name: "pibo-runtime-resource-verifier", version: "1.0.0" }, { capabilities: {} });

package/dist/pi-packages/cli.js

@@ -51,6 +51,7 @@ export async function runPiPackagesCli(argv = process.argv) {
             console.log("No Pi packages registered.");
             return;
         }
+        let hasErrors = false;
         for (const pkg of packages) {
             const diagnostics = [];
             try {
@@ -68,11 +69,15 @@ export async function runPiPackagesCli(argv = process.argv) {
                 }
             }
             const status = diagnostics.length || pkg.installStatus === "error" || pkg.installStatus === "missing" ? "error" : "ok";
+            if (status === "error")
+                hasErrors = true;
             console.log(`${pkg.name}\t${status}\t${pkg.installSpec}`);
             for (const diagnostic of [...pkg.diagnostics.map((item) => item.message), ...diagnostics]) {
                 console.log(`  ${diagnostic}`);
             }
         }
+        if (hasErrors)
+            process.exitCode = 1;
     });
     await program.parseAsync(argv);
 }

package/dist/previews/cli.js

@@ -1,9 +1,8 @@
 import { randomBytes } from "node:crypto";
 import { resolve } from "node:path";
 import { Command } from "commander";
-import { sanitizePreviewServerSettings } from "../core/preview-server-settings.js";
 import { createDefaultPiboDataSessionStore } from "../sessions/pibo-data-store.js";
-import { DEFAULT_PREVIEW_TTL_MINUTES, loadPreviewConfig, previewPublicURL, requirePreviewBaseURL } from "./config.js";
+import { DEFAULT_PREVIEW_TTL_MINUTES, loadEffectivePreviewServerSettings, loadPreviewConfig, previewPublicURL, requirePreviewBaseURL } from "./config.js";
 import { reconcileManagedPreviews, startManagedPreview, stopManagedPreview, validatePreviewStartCommand, } from "./manager.js";
 import { findPreviewTargetProcess, isPiboControlProcess, isPiboYieldedProcess, isPreviewTargetProcessCurrent, probePreviewTarget, validatePreviewPort, } from "./network.js";
 import { createDefaultPreviewStore, previewExposureState } from "./store.js";
@@ -264,10 +263,7 @@ export async function runPreviewCli(argv = process.argv) {
         const baseURL = requirePreviewBaseURL();
         if (!id) {
             const config = loadPreviewConfig();
-            const serverLimits = sanitizePreviewServerSettings({
-                maxRunningServers: config.maxRunningServers,
-                autoStopMinutes: config.autoStopMinutes,
-            });
+            const serverLimits = loadEffectivePreviewServerSettings();
             const store = createDefaultPreviewStore();
             let diagnostics;
             try {

package/dist/previews/config.js

@@ -1,4 +1,6 @@
 import { loadPiboConfig } from "../config/config.js";
+import { sanitizePreviewServerSettings } from "../core/preview-server-settings.js";
+import { loadPiboUserSettings } from "../core/user-settings.js";
 import { parsePreviewBaseURL } from "./base-url.js";
 export const DEFAULT_PREVIEW_TTL_MINUTES = 8 * 60;
 export const DEFAULT_PREVIEW_TICKET_TTL_SECONDS = 60;
@@ -6,6 +8,14 @@ export const DEFAULT_PREVIEW_SESSION_TTL_MINUTES = 8 * 60;
 export function loadPreviewConfig() {
     return loadPiboConfig().preview ?? {};
 }
+export function loadEffectivePreviewServerSettings() {
+    const config = loadPreviewConfig();
+    const userSettings = loadPiboUserSettings().previewServers;
+    return sanitizePreviewServerSettings({
+        maxRunningServers: config.maxRunningServers ?? userSettings.maxRunningServers,
+        autoStopMinutes: config.autoStopMinutes ?? userSettings.autoStopMinutes,
+    });
+}
 export function requirePreviewBaseURL(value = loadPreviewConfig().baseURL) {
     if (!value)
         throw new Error("preview.baseURL is required. Set it with `pibo config set preview.baseURL https://preview.example.com`.");