@pasko70/pibo 3.0.2 → 3.1.0

package/dist/reliability/store.js

@@ -5,6 +5,8 @@ import { ensurePrivatePiboHomeForPath, piboHomePath } from "../core/pibo-home.js
 import { protectPrivateFileSync } from "../core/private-path.js";
 import { sqliteTableColumns } from "../data/sqlite-schema.js";
 import { DatabaseSync } from "node:sqlite";
+const MAX_ATTEMPTS_ERROR = "Job exhausted retry attempts.";
+const MAX_ATTEMPTS_REASON = "max_attempts";
 function now() {
     return new Date().toISOString();
 }
@@ -352,41 +354,73 @@ export class PiboReliabilityStore {
     claimBatch(workerId, limit, options = {}) {
         const timestamp = now();
         const claimExpiresAt = new Date(Date.now() + (options.visibilityTimeoutMs ?? 30000)).toISOString();
-        const clauses = [
-            "((state = 'pending' AND run_at <= ?) OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?))",
-            "(expires_at IS NULL OR expires_at > ?)",
-        ];
-        const values = [timestamp, timestamp, timestamp];
-        if (options.queue) {
-            clauses.push("queue = ?");
-            values.push(options.queue);
-        }
-        this.moveExpiredJobs(timestamp);
-        const rows = this.db
-            .prepare(`
-				UPDATE pibo_jobs
-				SET state = 'running',
-					worker_id = ?,
-					claim_expires_at = ?,
-					claim_token = claim_token + 1,
-					attempts = attempts + 1,
-					updated_at = ?
-				WHERE job_id IN (
-					SELECT job_id FROM pibo_jobs
-					WHERE ${clauses.join(" AND ")}
-					ORDER BY priority DESC, run_at ASC, created_at ASC
-					LIMIT ?
-				)
-				RETURNING *
-			`)
-            .all(workerId, claimExpiresAt, timestamp, ...values, clampLimit(limit));
-        return rows.map(jobFromRow);
+        return this.inImmediateTransaction(() => {
+            const clauses = [
+                "((state = 'pending' AND run_at <= ?) OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?))",
+                "(expires_at IS NULL OR expires_at > ?)",
+                "attempts < max_attempts",
+            ];
+            const values = [timestamp, timestamp, timestamp];
+            if (options.queue) {
+                clauses.push("queue = ?");
+                values.push(options.queue);
+            }
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { queue: options.queue });
+            const rows = this.db
+                .prepare(`
+					UPDATE pibo_jobs
+					SET state = 'running',
+						worker_id = ?,
+						claim_expires_at = ?,
+						claim_token = claim_token + 1,
+						attempts = attempts + 1,
+						updated_at = ?
+					WHERE job_id IN (
+						SELECT job_id FROM pibo_jobs
+						WHERE ${clauses.join(" AND ")}
+						ORDER BY priority DESC, run_at ASC, created_at ASC
+						LIMIT ?
+					)
+					RETURNING *
+				`)
+                .all(workerId, claimExpiresAt, timestamp, ...values, clampLimit(limit));
+            return rows.map(jobFromRow);
+        });
     }
     claimJob(jobId, workerId, visibilityTimeoutMs = 30000) {
         const timestamp = now();
         const claimExpiresAt = new Date(Date.now() + visibilityTimeoutMs).toISOString();
-        const row = this.db
-            .prepare(`
+        return this.inImmediateTransaction(() => {
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { jobId });
+            const row = this.db
+                .prepare(`
+					UPDATE pibo_jobs
+					SET state = 'running',
+						worker_id = ?,
+						claim_expires_at = ?,
+						claim_token = claim_token + 1,
+						attempts = attempts + 1,
+						updated_at = ?
+					WHERE job_id = ?
+						AND state = 'pending'
+						AND run_at <= ?
+						AND attempts < max_attempts
+						AND (expires_at IS NULL OR expires_at > ?)
+					RETURNING *
+				`)
+                .get(workerId, claimExpiresAt, timestamp, jobId, timestamp, timestamp);
+            return row ? jobFromRow(row) : undefined;
+        });
+    }
+    claimRecoverableJob(jobId, workerId, visibilityTimeoutMs = 30000, forcePending = false) {
+        const timestamp = now();
+        const claimExpiresAt = new Date(Date.now() + visibilityTimeoutMs).toISOString();
+        return this.inImmediateTransaction(() => {
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { jobId });
+            const row = this.db.prepare(`
 				UPDATE pibo_jobs
 				SET state = 'running',
 					worker_id = ?,
@@ -395,34 +429,16 @@ export class PiboReliabilityStore {
 					attempts = attempts + 1,
 					updated_at = ?
 				WHERE job_id = ?
-					AND state = 'pending'
-					AND run_at <= ?
+					AND (
+						(state = 'pending' AND (? = 1 OR run_at <= ?))
+						OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
+					)
+					AND attempts < max_attempts
 					AND (expires_at IS NULL OR expires_at > ?)
 				RETURNING *
-			`)
-            .get(workerId, claimExpiresAt, timestamp, jobId, timestamp, timestamp);
-        return row ? jobFromRow(row) : undefined;
-    }
-    claimRecoverableJob(jobId, workerId, visibilityTimeoutMs = 30000, forcePending = false) {
-        const timestamp = now();
-        const claimExpiresAt = new Date(Date.now() + visibilityTimeoutMs).toISOString();
-        const row = this.db.prepare(`
-			UPDATE pibo_jobs
-			SET state = 'running',
-				worker_id = ?,
-				claim_expires_at = ?,
-				claim_token = claim_token + 1,
-				attempts = attempts + 1,
-				updated_at = ?
-			WHERE job_id = ?
-				AND (
-					(state = 'pending' AND (? = 1 OR run_at <= ?))
-					OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
-				)
-				AND (expires_at IS NULL OR expires_at > ?)
-			RETURNING *
-		`).get(workerId, claimExpiresAt, timestamp, jobId, forcePending ? 1 : 0, timestamp, timestamp, timestamp);
-        return row ? jobFromRow(row) : undefined;
+			`).get(workerId, claimExpiresAt, timestamp, jobId, forcePending ? 1 : 0, timestamp, timestamp, timestamp);
+            return row ? jobFromRow(row) : undefined;
+        });
     }
     updateJobPayload(jobId, workerId, payload, claimToken) {
         const result = this.db.prepare(`
@@ -436,15 +452,23 @@ export class PiboReliabilityStore {
     }
     releaseJob(jobId, workerId, delayMs = 0, claimToken) {
         const timestamp = now();
-        const runAt = new Date(Date.parse(timestamp) + Math.max(0, delayMs)).toISOString();
-        const result = this.db.prepare(`
-			UPDATE pibo_jobs
-			SET state = 'pending', worker_id = NULL, claim_expires_at = NULL, run_at = ?, updated_at = ?
-			WHERE job_id = ? AND state = 'running' AND worker_id = ?
-				AND (? IS NULL OR claim_token = ?)
-				AND claim_expires_at IS NOT NULL AND claim_expires_at > ?
-		`).run(runAt, timestamp, jobId, workerId, claimToken ?? null, claimToken ?? null, timestamp);
-        return Number(result.changes ?? 0) > 0;
+        return this.inImmediateTransaction(() => {
+            const row = this.getLiveWorkerJob(jobId, workerId, timestamp, claimToken);
+            if (!row)
+                return false;
+            if (row.attempts >= row.max_attempts) {
+                this.moveJobToDead(row, MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
+                return true;
+            }
+            const runAt = new Date(Date.parse(timestamp) + Math.max(0, delayMs)).toISOString();
+            const result = this.db.prepare(`
+				UPDATE pibo_jobs
+				SET state = 'pending', worker_id = NULL, claim_expires_at = NULL, run_at = ?, updated_at = ?
+				WHERE job_id = ? AND state = 'running' AND worker_id = ?
+					AND (? IS NULL OR claim_token = ?)
+			`).run(runAt, timestamp, jobId, workerId, claimToken ?? null, claimToken ?? null);
+            return Number(result.changes ?? 0) > 0;
+        });
     }
     ack(jobId, workerId, claimToken) {
         const timestamp = now();
@@ -469,7 +493,7 @@ export class PiboReliabilityStore {
                 return false;
             const job = jobFromRow(row);
             if (job.attempts >= job.maxAttempts) {
-                this.moveJobToDead(row, input.error ?? "Job exhausted retry attempts.", "max_attempts", timestamp);
+                this.moveJobToDead(row, input.error ?? MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
                 return true;
             }
             const delayMs = input.delayMs ?? retryDelayMs(job.attempts, input);
@@ -602,16 +626,21 @@ export class PiboReliabilityStore {
     }
     hasRecoverableJobs(queue, includeDeferredPending = false) {
         const timestamp = now();
-        return this.db.prepare(`
-			SELECT 1 AS found FROM pibo_jobs
-			WHERE queue = ?
-				AND (
-					(state = 'pending' AND (? = 1 OR run_at <= ?))
-					OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
-				)
-				AND (expires_at IS NULL OR expires_at > ?)
-			LIMIT 1
-		`).get(queue, includeDeferredPending ? 1 : 0, timestamp, timestamp, timestamp) !== undefined;
+        return this.inImmediateTransaction(() => {
+            this.moveExpiredJobs(timestamp);
+            this.moveExhaustedRecoverableJobs(timestamp, { queue });
+            return this.db.prepare(`
+				SELECT 1 AS found FROM pibo_jobs
+				WHERE queue = ?
+					AND (
+						(state = 'pending' AND (? = 1 OR run_at <= ?))
+						OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?)
+					)
+					AND attempts < max_attempts
+					AND (expires_at IS NULL OR expires_at > ?)
+				LIMIT 1
+			`).get(queue, includeDeferredPending ? 1 : 0, timestamp, timestamp, timestamp) !== undefined;
+        });
     }
     quarantineJob(jobId, reason, correlation = {}) {
         const row = this.db.prepare("SELECT * FROM pibo_jobs WHERE job_id = ?").get(jobId);
@@ -749,46 +778,62 @@ export class PiboReliabilityStore {
         return Number(result.changes ?? 0);
     }
     recoverInterruptedRuns(workerId = `run-registry:${process.pid}`) {
-        const rows = this.db.prepare("SELECT * FROM pibo_runs WHERE status = 'running'").all();
-        const recovered = [];
-        const timestamp = now();
-        for (const row of rows) {
-            if (row.job_id && this.hasUnexpiredJobClaim(row.job_id, timestamp, workerId))
-                continue;
-            const run = runFromRow(row);
-            if (run.timeoutAt && run.timeoutAt <= timestamp) {
-                const error = `Run deadline ${run.timeoutAt} elapsed before the interrupted runtime recovered.`;
-                if (run.jobId)
-                    this.moveLiveJobToDead(run.jobId, error, "timeout", timestamp);
-                recovered.push(this.updateRun(run.runId, {
-                    status: "timed_out",
-                    error,
-                    timeoutPhase: "lifetime",
-                    summary: `${run.toolName} run started successfully, then reached its configured timeout.`,
-                    completedAt: timestamp,
-                }) ?? run);
-                continue;
-            }
-            if (run.retryable && run.maxAttempts > 1) {
-                if (run.jobId)
-                    this.releaseJobForRetry(run.jobId, timestamp);
-                recovered.push(this.updateRun(run.runId, {
-                    status: "queued",
-                    summary: `${run.toolName} run is queued for retry after interruption.`,
-                }) ?? run);
-            }
-            else {
-                if (run.jobId)
-                    this.moveLiveJobToDead(run.jobId, "Run was interrupted before completion and the tool is not retryable.", "interrupted", timestamp);
+        return this.inImmediateTransaction(() => {
+            const rows = this.db.prepare("SELECT * FROM pibo_runs WHERE status = 'running'").all();
+            const recovered = [];
+            const timestamp = now();
+            for (const row of rows) {
+                if (row.job_id && this.hasUnexpiredJobClaim(row.job_id, timestamp, workerId))
+                    continue;
+                const run = runFromRow(row);
+                if (run.timeoutAt && run.timeoutAt <= timestamp) {
+                    const error = `Run deadline ${run.timeoutAt} elapsed before the interrupted runtime recovered.`;
+                    if (run.jobId)
+                        this.moveLiveJobToDead(run.jobId, error, "timeout", timestamp);
+                    recovered.push(this.updateRun(run.runId, {
+                        status: "timed_out",
+                        error,
+                        timeoutPhase: "lifetime",
+                        summary: `${run.toolName} run started successfully, then reached its configured timeout.`,
+                        completedAt: timestamp,
+                    }) ?? run);
+                    continue;
+                }
+                const jobRow = run.jobId
+                    ? this.db.prepare("SELECT * FROM pibo_jobs WHERE job_id = ?").get(run.jobId)
+                    : undefined;
+                if (run.retryable && jobRow && jobRow.attempts < jobRow.max_attempts) {
+                    this.releaseJobForRetry(jobRow.job_id, timestamp);
+                    recovered.push(this.updateRun(run.runId, {
+                        status: "queued",
+                        summary: `${run.toolName} run is queued for retry after interruption.`,
+                    }) ?? run);
+                    continue;
+                }
+                if (run.retryable && jobRow && jobRow.attempts >= jobRow.max_attempts) {
+                    this.moveJobToDead(jobRow, MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
+                    recovered.push(this.updateRun(run.runId, {
+                        status: "failed",
+                        error: MAX_ATTEMPTS_ERROR,
+                        summary: `${run.toolName} run failed after exhausting retry attempts.`,
+                        completedAt: timestamp,
+                    }) ?? run);
+                    continue;
+                }
+                const error = run.retryable
+                    ? "Run was interrupted before completion and its retry job is no longer available."
+                    : "Run was interrupted before completion and the tool is not retryable.";
+                if (jobRow)
+                    this.moveJobToDead(jobRow, error, "interrupted", timestamp);
                 recovered.push(this.updateRun(run.runId, {
                     status: "failed",
-                    error: "Run was interrupted before completion and the tool is not retryable.",
+                    error,
                     summary: `${run.toolName} run failed.`,
                     completedAt: timestamp,
                 }) ?? run);
             }
-        }
-        return recovered;
+            return recovered;
+        });
     }
     close() {
         this.db.close();
@@ -843,6 +888,24 @@ export class PiboReliabilityStore {
         for (const row of expired)
             this.moveJobToDead(row, row.last_error ?? "Job expired.", "expired", timestamp);
     }
+    moveExhaustedRecoverableJobs(timestamp, options = {}) {
+        const clauses = [
+            "attempts >= max_attempts",
+            "(state = 'pending' OR (state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ?))",
+        ];
+        const values = [timestamp];
+        if (options.jobId) {
+            clauses.push("job_id = ?");
+            values.push(options.jobId);
+        }
+        if (options.queue) {
+            clauses.push("queue = ?");
+            values.push(options.queue);
+        }
+        const exhausted = this.db.prepare(`SELECT * FROM pibo_jobs WHERE ${clauses.join(" AND ")}`).all(...values);
+        for (const row of exhausted)
+            this.moveJobToDead(row, MAX_ATTEMPTS_ERROR, MAX_ATTEMPTS_REASON, timestamp);
+    }
     hasUnexpiredJobClaim(jobId, timestamp, workerId) {
         const row = this.db
             .prepare(`

package/dist/session-ui/terminalRows.js

@@ -63,7 +63,8 @@ function applyToolDisplayMode(rows, mode) {
     });
 }
 function isToolDisplayRow(row) {
-    return row.id.startsWith("terminal:tool:")
+    return row.sourceNodeIds.some((nodeId) => parseTraceToolNodeIdentity(nodeId) !== undefined)
+        || row.id.startsWith("terminal:tool:")
         || row.kind === "tool.call"
         || row.kind === "tool.image"
         || row.kind === "tool.group.exploring"

package/dist/subagents/observation-query.js

@@ -0,0 +1,121 @@
+import { PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES, normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, normalizePiboAgentObservationToolDetail, parsePiboAgentObservationTimestamp, piboAgentObservationKind, piboAgentObservationToolSummary, } from "./observations.js";
+export function preparePiboAgentObservationQuery(input = {}) {
+    const order = normalizePiboAgentObservationOrder(input.order);
+    const limit = normalizePiboAgentObservationLimit(input.limit);
+    const toolDetail = normalizePiboAgentObservationToolDetail(input.toolDetail);
+    const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
+    const since = parsePiboAgentObservationTimestamp(input.since, "since");
+    const until = parsePiboAgentObservationTimestamp(input.until, "until");
+    if (since !== undefined && until !== undefined && since > until) {
+        throw new Error("Agent observation since must not be after until.");
+    }
+    if (input.toolCallIds && input.toolCallIds.length > 50) {
+        throw new Error("Agent observation toolCallIds must contain at most 50 entries.");
+    }
+    const requestIds = input.requestIds ? new Set(input.requestIds) : undefined;
+    const toolCallIds = input.toolCallIds ? new Set(input.toolCallIds) : undefined;
+    const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
+    const names = input.names ? new Set(input.names) : undefined;
+    const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
+    const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
+    const kinds = input.kinds ? new Set(input.kinds) : undefined;
+    const roles = input.roles ? new Set(input.roles) : undefined;
+    const textContains = input.textContains?.toLowerCase();
+    const defaultMessageView = eventTypes === undefined && kinds === undefined;
+    const explicitlySelectsTools = input.eventTypes?.some((eventType) => piboAgentObservationKind(eventType) === "tool") === true
+        || input.kinds?.includes("tool") === true
+        || toolCallIds !== undefined;
+    const includeTools = input.includeTools === true || (input.includeTools === undefined && explicitlySelectsTools);
+    const defaultEventTypes = includeTools
+        ? [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, ...PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES]
+        : [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES];
+    const defaultEventTypeSet = new Set(defaultEventTypes);
+    const scanEventTypes = defaultMessageView
+        ? defaultEventTypes
+        : input.eventTypes && input.eventTypes.length > 0
+            ? [...input.eventTypes]
+            : undefined;
+    return {
+        filters: {
+            ...input,
+            ...(defaultMessageView ? { eventTypes: defaultEventTypes } : {}),
+            ...(afterSequence !== undefined ? { afterSequence } : {}),
+            order,
+            limit,
+            includeTools,
+            toolDetail,
+            includeDetails: input.includeDetails === true,
+        },
+        ...(afterSequence !== undefined ? { afterSequence } : {}),
+        order,
+        scanOrder: afterSequence !== undefined ? "asc" : order,
+        limit,
+        includeTools,
+        toolDetail,
+        ...(scanEventTypes ? { scanEventTypes } : {}),
+        matches(observation) {
+            if (requestIds && (!observation.requestId || !requestIds.has(observation.requestId)))
+                return false;
+            if (toolCallIds && (!observation.toolCallId || !toolCallIds.has(observation.toolCallId)))
+                return false;
+            if (agentIds && !agentIds.has(observation.agentId))
+                return false;
+            if (names && !names.has(observation.name))
+                return false;
+            if (threadKeys && (!observation.threadKey || !threadKeys.has(observation.threadKey)))
+                return false;
+            if (observation.kind === "tool" && !includeTools)
+                return false;
+            if (defaultMessageView && !defaultEventTypeSet.has(observation.eventType))
+                return false;
+            if (eventTypes && !eventTypes.has(observation.eventType))
+                return false;
+            if (kinds && !kinds.has(observation.kind))
+                return false;
+            if (roles && (!observation.role || !roles.has(observation.role)))
+                return false;
+            if (afterSequence !== undefined && observation.sequence <= afterSequence)
+                return false;
+            const createdAt = Date.parse(observation.createdAt);
+            if (since !== undefined && createdAt < since)
+                return false;
+            if (until !== undefined && createdAt > until)
+                return false;
+            if (textContains && !(observation.text ?? "").toLowerCase().includes(textContains))
+                return false;
+            return true;
+        },
+    };
+}
+export function selectPiboAgentObservationPage(observations, query, options = {}) {
+    const matches = [];
+    for (const observation of observations) {
+        if (!query.matches(observation))
+            continue;
+        matches.push(observation);
+        if (matches.length > query.limit)
+            break;
+    }
+    const pageLimited = matches.length > query.limit;
+    const selected = matches.slice(0, query.limit);
+    if (query.afterSequence !== undefined && query.order === "desc")
+        selected.reverse();
+    const projected = selected.map((observation) => {
+        const { details, ...visible } = observation;
+        const compact = visible.kind === "tool" && query.toolDetail === "summary"
+            ? { ...visible, text: piboAgentObservationToolSummary(visible.text, visible.isError, details) }
+            : visible;
+        return query.filters.includeDetails === true && details !== undefined ? { ...compact, details } : compact;
+    });
+    const evictedThrough = options.evictedThrough ?? 0;
+    const retentionTruncated = query.afterSequence === undefined
+        ? evictedThrough > 0
+        : query.afterSequence < evictedThrough;
+    const nextAfterSequence = projected.reduce((maximum, observation) => Math.max(maximum, observation.sequence), query.afterSequence === undefined ? 0 : Math.max(query.afterSequence, evictedThrough));
+    return {
+        filters: query.filters,
+        observations: projected,
+        nextAfterSequence,
+        truncated: retentionTruncated || pageLimited,
+    };
+}

package/dist/tools/agent-browser-leases.js

@@ -68,6 +68,28 @@ async function withRegistryLock(status, action) {
 function isExpired(lease, now = new Date()) {
     return new Date(lease.expiresAt).getTime() <= now.getTime();
 }
+function leaseTimestamp(lease) {
+    const updatedAt = Date.parse(lease.updatedAt);
+    if (Number.isFinite(updatedAt))
+        return updatedAt;
+    const createdAt = Date.parse(lease.createdAt);
+    return Number.isFinite(createdAt) ? createdAt : 0;
+}
+function deduplicateLeaseIdentities(registry) {
+    const leasesById = new Map();
+    for (const lease of registry.leases) {
+        const existing = leasesById.get(lease.id);
+        if (!existing) {
+            leasesById.set(lease.id, lease);
+            continue;
+        }
+        const preferLease = lease.status === 'active' && existing.status !== 'active'
+            || lease.status === existing.status && leaseTimestamp(lease) > leaseTimestamp(existing);
+        if (preferLease)
+            leasesById.set(lease.id, lease);
+    }
+    registry.leases = [...leasesById.values()];
+}
 function copyFilter(source) {
     const base = source.split(/[\\/]/).pop() || '';
     return ![
@@ -114,6 +136,7 @@ export async function acquireAgentBrowserLease(status, options) {
     const maxSlots = options.maxSlots ?? 4;
     const result = await withRegistryLock(status, async () => {
         const registry = readRegistry(status);
+        deduplicateLeaseIdentities(registry);
         const now = new Date();
         for (const lease of registry.leases) {
             if (lease.status === 'active' && isExpired(lease, now)) {
@@ -131,34 +154,44 @@ export async function acquireAgentBrowserLease(status, options) {
                 suggestion: 'Release a lease or rerun with a higher --max-slots value.',
             }));
         }
-        const used = new Set(active.map((lease) => lease.slot));
-        let slotNumber = 1;
-        while (used.has(`slot-${String(slotNumber).padStart(3, '0')}`))
-            slotNumber += 1;
-        const slot = `slot-${String(slotNumber).padStart(3, '0')}`;
-        const sessionName = `pibo-auth-${app}-${slot}`;
-        const profileDir = leaseProfileDir(status, app, slot);
-        const lease = {
-            id: `${app}-${slot}`,
-            app,
-            holder,
-            slot,
-            sessionName,
-            profileDir,
-            status: 'active',
-            createdAt: nowIso(),
-            updatedAt: nowIso(),
-            expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
-        };
-        await rm(profileDir, { recursive: true, force: true });
+        let lease = registry.leases.find((item) => item.app === app && item.status === 'released');
+        if (lease) {
+            lease.holder = holder;
+            lease.status = 'active';
+            lease.updatedAt = nowIso();
+            lease.expiresAt = new Date(now.getTime() + ttlMs).toISOString();
+        }
+        else {
+            const used = new Set(active.map((item) => item.slot));
+            let slotNumber = 1;
+            while (used.has(`slot-${String(slotNumber).padStart(3, '0')}`))
+                slotNumber += 1;
+            const slot = `slot-${String(slotNumber).padStart(3, '0')}`;
+            const sessionName = `pibo-auth-${app}-${slot}`;
+            const profileDir = leaseProfileDir(status, app, slot);
+            const createdAt = nowIso();
+            lease = {
+                id: `${app}-${slot}`,
+                app,
+                holder,
+                slot,
+                sessionName,
+                profileDir,
+                status: 'active',
+                createdAt,
+                updatedAt: createdAt,
+                expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+            };
+            registry.leases.push(lease);
+        }
+        await rm(lease.profileDir, { recursive: true, force: true });
         const sourceTemplate = templateDir(status, app);
         if (existsSync(sourceTemplate)) {
-            await cp(sourceTemplate, profileDir, { recursive: true, force: true, filter: copyFilter });
+            await cp(sourceTemplate, lease.profileDir, { recursive: true, force: true, filter: copyFilter });
         }
         else {
-            await mkdir(profileDir, { recursive: true });
+            await mkdir(lease.profileDir, { recursive: true });
         }
-        registry.leases.push(lease);
         await writeRegistry(status, registry);
         return lease;
     });
@@ -187,6 +220,7 @@ export async function listAgentBrowserLeases(status, json = false) {
 export async function releaseAgentBrowserLease(status, id, options) {
     await withRegistryLock(status, async () => {
         const registry = readRegistry(status);
+        deduplicateLeaseIdentities(registry);
         const lease = registry.leases.find((item) => item.id === id);
         if (!lease)
             throw new Error(`Agent Browser lease not found: ${id}`);
@@ -202,6 +236,7 @@ export async function reapStaleAgentBrowserLeases(status, json = false) {
     let released = 0;
     await withRegistryLock(status, async () => {
         const registry = readRegistry(status);
+        deduplicateLeaseIdentities(registry);
         const now = new Date();
         for (const lease of registry.leases) {
             if (lease.status === 'active' && isExpired(lease, now)) {

package/dist/tools/agent-browser-wrapper.js

@@ -89,7 +89,7 @@ exec "$real_agent_browser" "\${args[@]}"
 `;
 }
 export function ensureAgentBrowserWrapper(status) {
-    if (!status.homeDir || !status.executablePath)
+    if (!status.installed || !status.homeDir || !status.executablePath)
         return undefined;
     const wrapperPath = join(status.homeDir, 'bin', 'agent-browser');
     mkdirSync(dirname(wrapperPath), { recursive: true });