@pasko70/pibo 3.2.3 → 3.2.5

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;
@@ -18,7 +34,7 @@ export class PayloadStore {
         const createdAt = input.createdAt ?? new Date().toISOString();
         const bytes = payloadToBytes(input.value, contentType);
         const sha256 = createHash("sha256").update(bytes).digest("hex");
-        const existing = this.findBySha256(sha256);
+        const existing = this.findByIdentity(sha256, contentType, input.retentionClass);
         if (existing) {
             this.db.prepare("UPDATE payloads SET ref_count = ref_count + 1 WHERE id = ?").run(existing.id);
             return this.getPayload(existing.id) ?? existing;
@@ -27,7 +43,7 @@ export class PayloadStore {
         const encoding = shouldCompress ? "gzip" : "identity";
         const bytesToStore = shouldCompress ? gzipSync(bytes) : bytes;
         const compressedByteSize = shouldCompress ? bytesToStore.byteLength : null;
-        const relativePath = buildRelativePayloadPath(sha256, contentType, encoding);
+        const relativePath = buildRelativePayloadPath(sha256, contentType, input.retentionClass, encoding);
         const absolutePath = this.rootDir === ":memory:" ? relativePath : join(this.rootDir, relativePath);
         writePayloadFile(absolutePath, bytesToStore);
         const id = input.id ?? `payload_${randomUUID()}`;
@@ -108,9 +124,35 @@ export class PayloadStore {
         return JSON.parse(Buffer.from(this.readPayloadBytesBounded(id, maxBytes)).toString("utf8"));
     }
     findBySha256(sha256) {
-        const row = this.db.prepare("SELECT * FROM payloads WHERE sha256 = ?").get(sha256);
+        const row = this.db.prepare("SELECT * FROM payloads WHERE sha256 = ? ORDER BY created_at ASC, id ASC LIMIT 1").get(sha256);
+        return row ? payloadFromRow(row) : undefined;
+    }
+    findByIdentity(sha256, contentType, retentionClass) {
+        const row = this.db.prepare(`
+			SELECT * FROM payloads
+			WHERE sha256 = ? AND content_type = ? AND retention_class = ?
+		`).get(sha256, contentType, retentionClass);
         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");
@@ -147,12 +189,12 @@ function defaultContentType(value) {
     return "application/json";
 }
 function payloadToBytes(value, contentType) {
-    if (typeof value === "string")
-        return Buffer.from(value, "utf8");
     if (value instanceof Uint8Array)
         return value;
     if (contentType.includes("json"))
         return Buffer.from(JSON.stringify(value), "utf8");
+    if (typeof value === "string")
+        return Buffer.from(value, "utf8");
     return Buffer.from(String(value), "utf8");
 }
 function previewTextFromValue(value) {
@@ -162,10 +204,16 @@ function previewTextFromValue(value) {
     const normalized = text.replace(/\s+/g, " ").trim();
     return normalized ? normalized.slice(0, 1024) : undefined;
 }
-function buildRelativePayloadPath(sha256, contentType, encoding) {
+function buildRelativePayloadPath(sha256, contentType, retentionClass, encoding) {
     const extension = extensionForContentType(contentType);
     const suffix = encoding === "gzip" ? `${extension}.gz` : extension;
-    return join("sha256", sha256.slice(0, 2), sha256.slice(2, 4), `${sha256}.${suffix}`);
+    const metadataHash = createHash("sha256")
+        .update(contentType)
+        .update("\0")
+        .update(retentionClass)
+        .digest("hex")
+        .slice(0, 16);
+    return join("sha256", sha256.slice(0, 2), sha256.slice(2, 4), `${sha256}.${metadataHash}.${suffix}`);
 }
 function extensionForContentType(contentType) {
     if (contentType.includes("json"))

package/dist/data/schema.js

@@ -1,5 +1,27 @@
-export const PIBO_DATA_SCHEMA_VERSION = 7;
+export const PIBO_DATA_SCHEMA_VERSION = 8;
+const NATIVE_HISTORY_FALLBACK_SCHEMA_VERSION = 5;
 const retiredScopeColumn = ["owner", "scope"].join("_");
+const payloadTableDefinition = `
+	id TEXT PRIMARY KEY,
+	sha256 TEXT NOT NULL,
+	storage_kind TEXT NOT NULL,
+	storage_path TEXT,
+	content_type TEXT NOT NULL,
+	encoding TEXT NOT NULL DEFAULT 'gzip',
+	byte_size INTEGER NOT NULL,
+	compressed_byte_size INTEGER,
+	preview_text TEXT,
+	retention_class TEXT NOT NULL,
+	ref_count INTEGER NOT NULL DEFAULT 0,
+	status TEXT NOT NULL DEFAULT 'committed',
+	created_at TEXT NOT NULL,
+	last_verified_at TEXT
+`;
+const payloadTableColumns = [
+    "id", "sha256", "storage_kind", "storage_path", "content_type", "encoding",
+    "byte_size", "compressed_byte_size", "preview_text", "retention_class", "ref_count",
+    "status", "created_at", "last_verified_at",
+];
 const retiredScopeTables = [
     {
         name: "sessions",
@@ -92,6 +114,26 @@ function rebuildRetiredScopeTables(db, tablesToRebuild) {
 		`);
     }
 }
+function payloadTableNeedsMetadataIdentityRebuild(db) {
+    const table = db.prepare("SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = 'payloads'").get();
+    if (!table)
+        return false;
+    const indexes = db.prepare("SELECT name FROM pragma_index_list('payloads') WHERE \"unique\" = 1").all();
+    return indexes.some((index) => {
+        const columns = db.prepare("SELECT name FROM pragma_index_info(?) ORDER BY seqno").all(index.name);
+        return columns.length === 1 && columns[0]?.name === "sha256";
+    });
+}
+function rebuildPayloadTableForMetadataIdentity(db) {
+    const columns = payloadTableColumns.join(", ");
+    db.exec(`
+		DROP TABLE IF EXISTS __pibo_schema_v8_payloads;
+		CREATE TABLE __pibo_schema_v8_payloads (${payloadTableDefinition});
+		INSERT INTO __pibo_schema_v8_payloads (${columns}) SELECT ${columns} FROM payloads;
+		DROP TABLE payloads;
+		ALTER TABLE __pibo_schema_v8_payloads RENAME TO payloads;
+	`);
+}
 export function assertSupportedPiboDataSchemaVersion(db) {
     const version = Number(db.prepare("PRAGMA user_version").get()?.user_version ?? 0);
     if (version > PIBO_DATA_SCHEMA_VERSION) {
@@ -100,6 +142,7 @@ export function assertSupportedPiboDataSchemaVersion(db) {
     return version;
 }
 export const PIBO_DATA_SCHEMA_MIGRATION_STEPS = [
+    "payload-metadata-identity",
     "schema",
     "runtime-bindings",
     "render-high-water",
@@ -113,20 +156,22 @@ export const PIBO_DATA_SCHEMA_MIGRATION_STEPS = [
 export function applyPiboDataSchema(db, hooks = {}) {
     const previousVersion = assertSupportedPiboDataSchemaVersion(db);
     const tablesToRebuild = retiredScopeTablesToRebuild(db);
+    const rebuildPayloadTable = payloadTableNeedsMetadataIdentityRebuild(db);
+    const requiresTableRebuild = tablesToRebuild.length > 0 || rebuildPayloadTable;
     const ownsTransaction = !db.isTransaction;
-    if (!ownsTransaction && tablesToRebuild.length > 0) {
+    if (!ownsTransaction && requiresTableRebuild) {
         throw new Error("Pibo data schema migration requires an independent transaction");
     }
     const foreignKeysEnabled = ownsTransaction
-        && tablesToRebuild.length > 0
+        && requiresTableRebuild
         && Number(db.prepare("PRAGMA foreign_keys").get().foreign_keys ?? 0) === 1;
     if (foreignKeysEnabled)
         db.exec("PRAGMA foreign_keys = OFF");
     try {
         if (ownsTransaction)
             db.exec("BEGIN IMMEDIATE");
-        applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild);
-        if (tablesToRebuild.length > 0) {
+        applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild, rebuildPayloadTable);
+        if (requiresTableRebuild) {
             const violations = db.prepare("PRAGMA foreign_key_check").all();
             if (violations.length > 0) {
                 throw new Error(`Pibo data schema migration would retain ${violations.length} foreign-key violation(s)`);
@@ -145,11 +190,14 @@ export function applyPiboDataSchema(db, hooks = {}) {
             db.exec("PRAGMA foreign_keys = ON");
     }
 }
-function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild) {
+function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild, rebuildPayloadTable) {
     const existingSessionCount = db.prepare("SELECT COUNT(*) AS count FROM sqlite_schema WHERE type = 'table' AND name = 'sessions'").get();
     const hadSessionsBeforeMigration = existingSessionCount.count > 0
         && Number(db.prepare("SELECT COUNT(*) AS count FROM sessions").get().count) > 0;
     rebuildRetiredScopeTables(db, tablesToRebuild);
+    if (rebuildPayloadTable)
+        rebuildPayloadTableForMetadataIdentity(db);
+    hooks.afterStep?.("payload-metadata-identity");
     db.exec(`
 		CREATE TABLE IF NOT EXISTS sessions (
 			id TEXT PRIMARY KEY,
@@ -199,6 +247,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,
@@ -292,22 +347,9 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
 		);
 
 
-		CREATE TABLE IF NOT EXISTS payloads (
-			id TEXT PRIMARY KEY,
-			sha256 TEXT NOT NULL UNIQUE,
-			storage_kind TEXT NOT NULL,
-			storage_path TEXT,
-			content_type TEXT NOT NULL,
-			encoding TEXT NOT NULL DEFAULT 'gzip',
-			byte_size INTEGER NOT NULL,
-			compressed_byte_size INTEGER,
-			preview_text TEXT,
-			retention_class TEXT NOT NULL,
-			ref_count INTEGER NOT NULL DEFAULT 0,
-			status TEXT NOT NULL DEFAULT 'committed',
-			created_at TEXT NOT NULL,
-			last_verified_at TEXT
-		);
+		CREATE TABLE IF NOT EXISTS payloads (${payloadTableDefinition});
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_payloads_identity
+			ON payloads(sha256, content_type, retention_class);
 
 		CREATE TABLE IF NOT EXISTS event_log (
 			stream_id INTEGER PRIMARY KEY,
@@ -784,7 +826,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 }),