@pentoshi/clai 3.8.49 → 3.8.51

package/dist/tools/jobs.d.ts

@@ -16,6 +16,8 @@ export interface JobLinkMetadata {
     parentTaskId?: string | undefined;
     wakeOnCompletion?: boolean | undefined;
     monitor?: JobMonitorMetadata | undefined;
+    /** Runtime listening lease that authorized this responder delegation. */
+    responderLeaseId?: string | undefined;
     /**
      * Opt-in delegation to the Responder: fire-and-continue, plan subtask +
      * auto-wake on completion, and inclusion in the Responder inbox/UI. When
@@ -59,7 +61,7 @@ export interface BackgroundJob extends JobLinkMetadata {
         target: string;
         expiresAt?: string | undefined;
     } | undefined;
-    /** Optional execution deadline for finite durable jobs. */
+    /** Accepted when reading legacy registries but never armed or restored. */
     timeoutAt?: string | undefined;
 }
 export declare function formatJobElapsed(job: Pick<BackgroundJob, "startedAt" | "endedAt">, now?: number): string;
@@ -81,9 +83,12 @@ export interface ResponderNotification {
     wakeOnCompletion: boolean;
     responder: boolean;
     monitor?: JobMonitorMetadata | undefined;
+    responderLeaseId?: string | undefined;
     deliveredAt?: string | undefined;
     analyzedAt?: string | undefined;
     acknowledgedAt?: string | undefined;
+    archivedAt?: string | undefined;
+    settledAt?: string | undefined;
 }
 export type JobManagerChange = {
     type: "job";
@@ -113,7 +118,7 @@ export interface StartJobOptions extends JobLinkMetadata {
     ownerSessionId?: string | undefined;
     profile?: string | undefined;
     estimatedSeconds?: number | undefined;
-    /** Stop this finite job after the selected duration. */
+    /** Legacy compatibility input. Durable jobs no longer have generic deadlines. */
     timeoutMs?: number | undefined;
     authorization?: {
         target: string;
@@ -127,9 +132,19 @@ export declare class JobManager {
     private processes;
     private writers;
     private abortControllers;
-    private deadlineTimers;
+    private authorizationTimers;
+    private responderLeases;
+    private settlementTimers;
+    private settlementAttempts;
     private finalizations;
     private listeners;
+    /**
+     * Tracks the first time a live job (with no ChildProcess handle) failed the
+     * liveness check, so we only finalize it as "lost" after a sustained grace
+     * window instead of on a single transient miss. Cleared as soon as the job is
+     * observed alive again or finalized.
+     */
+    private livenessMisses;
     private registryRetryTimer;
     private readonly registryPath;
     private readonly transientV2RegistryPath;
@@ -140,7 +155,11 @@ export declare class JobManager {
     private emit;
     subscribe(listener: JobManagerListener): () => void;
     private matchesSession;
-    private clearJobDeadline;
+    private clearAuthorizationTimer;
+    private scheduleAuthorizationExpiry;
+    activateResponderLease(sessionId: string): string;
+    getResponderLeaseId(sessionId: string | undefined): string | undefined;
+    releaseResponderLease(sessionId: string, leaseId?: string): void;
     private cloneReceipt;
     private notificationForJob;
     private ensureCompletionNotification;
@@ -148,8 +167,7 @@ export declare class JobManager {
     private finalizeJob;
     /** Reconcile a restored process that no longer has a ChildProcess close event. */
     private refreshJobLiveness;
-    /** Arm or restore a persisted finite-job deadline. */
-    private scheduleJobDeadline;
+    private scheduleTaskSettlement;
     /**
      * Register an in-flight tool for stall tracking only.
      * Never appears in shell.jobs and never touches the durable registry.
@@ -166,6 +184,7 @@ export declare class JobManager {
     getJob(id: string): BackgroundJob | undefined;
     getPendingNotifications(sessionId?: string): ResponderNotification[];
     pendingNotifications(sessionId?: string): ResponderNotification[];
+    claimNextResponderNotification(sessionId: string, leaseId: string): ResponderNotification | undefined;
     markDelivered(notificationId: string): boolean;
     markAnalyzed(notificationId: string): boolean;
     acknowledge(notificationId: string): boolean;

package/dist/tools/jobs.js

@@ -40,10 +40,21 @@ const TRANSIENT_V2_REGISTRY_FILE = "registry-v2.json";
 const MAX_DURABLE_TERMINAL_JOBS = 80;
 /** Drop terminal durable jobs older than this on load/list. */
 const TERMINAL_JOB_MAX_AGE_MS = 48 * 60 * 60 * 1000;
+const ARCHIVED_UNSETTLED_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const MAX_ARCHIVED_UNSETTLED_NOTIFICATIONS = 40;
 /** Max lines shell.jobs returns to the model (running first, then recent). */
 const LIST_JOBS_MAX_LINES = 40;
 /** Coalesce window for chatty stdout/stderr progress persistence + UI events. */
 const PROGRESS_FLUSH_MS = 250;
+/**
+ * A live job with no in-process ChildProcess handle (resumed session, or a
+ * handle that was released) is only declared "lost" after failing the liveness
+ * check continuously for this long. A single transient `ps`/`kill` hiccup — or
+ * an identity read that momentarily fails — must never finalize a job that is
+ * actually still running (which produced premature "result ready", a "<1s"
+ * elapsed, and a ✗ status=lost that later flipped back to exit=0).
+ */
+const LIVENESS_LOST_GRACE_MS = 8_000;
 /**
  * Number of trailing bytes in `buf` that form an incomplete multi-byte UTF-8
  * sequence (a lead byte whose continuation bytes were cut off by the read
@@ -73,8 +84,11 @@ function processAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        // EPERM means the process EXISTS but we lack permission to signal it
+        // (common for detached jobs in another process group) — that is alive, not
+        // gone. Only ESRCH ("no such process") proves it is truly dead.
+        return error.code === "EPERM";
     }
 }
 function processIdentity(pid) {
@@ -229,9 +243,19 @@ export class JobManager {
     processes = new Map();
     writers = new Map();
     abortControllers = new Map();
-    deadlineTimers = new Map();
+    authorizationTimers = new Map();
+    responderLeases = new Map();
+    settlementTimers = new Map();
+    settlementAttempts = new Map();
     finalizations = new Map();
     listeners = new Set();
+    /**
+     * Tracks the first time a live job (with no ChildProcess handle) failed the
+     * liveness check, so we only finalize it as "lost" after a sustained grace
+     * window instead of on a single transient miss. Cleared as soon as the job is
+     * observed alive again or finalized.
+     */
+    livenessMisses = new Map();
     registryRetryTimer;
     registryPath;
     transientV2RegistryPath;
@@ -269,11 +293,60 @@ export class JobManager {
             return true;
         return job.ownerSessionId === sessionId;
     }
-    clearJobDeadline(id) {
-        const timer = this.deadlineTimers.get(id);
+    clearAuthorizationTimer(id) {
+        const timer = this.authorizationTimers.get(id);
         if (timer)
             clearTimeout(timer);
-        this.deadlineTimers.delete(id);
+        this.authorizationTimers.delete(id);
+    }
+    scheduleAuthorizationExpiry(job) {
+        this.clearAuthorizationTimer(job.id);
+        const raw = job.authorization?.expiresAt;
+        if (!raw || !this.isLive(job))
+            return;
+        const expiresAt = Date.parse(raw);
+        if (!Number.isFinite(expiresAt))
+            return;
+        const timer = setTimeout(() => {
+            this.authorizationTimers.delete(job.id);
+            this.refreshJobLiveness(job);
+            if (this.isLive(job))
+                void this.stopJob(job.id, { graceMs: 1_000 });
+        }, Math.max(0, expiresAt - Date.now()));
+        timer.unref?.();
+        this.authorizationTimers.set(job.id, timer);
+    }
+    activateResponderLease(sessionId) {
+        const current = this.responderLeases.get(sessionId);
+        if (current)
+            return current;
+        const leaseId = randomUUID();
+        this.responderLeases.set(sessionId, leaseId);
+        this.emit({ type: "job", jobId: `responder:${sessionId}` });
+        return leaseId;
+    }
+    getResponderLeaseId(sessionId) {
+        return sessionId ? this.responderLeases.get(sessionId) : undefined;
+    }
+    releaseResponderLease(sessionId, leaseId) {
+        const current = this.responderLeases.get(sessionId);
+        if (!current || (leaseId && current !== leaseId))
+            return;
+        this.responderLeases.delete(sessionId);
+        const archivedAt = new Date().toISOString();
+        let changed = false;
+        for (const notification of this.notifications.values()) {
+            if (notification.ownerSessionId === sessionId &&
+                notification.responderLeaseId === current &&
+                !notification.acknowledgedAt &&
+                !notification.archivedAt) {
+                notification.archivedAt = archivedAt;
+                changed = true;
+            }
+        }
+        if (changed && !this.persistSync())
+            this.scheduleRegistryRetry();
+        this.emit({ type: "job", jobId: `responder:${sessionId}` });
     }
     cloneReceipt(receipt) {
         return { ...receipt, chunks: [...receipt.chunks] };
@@ -301,6 +374,9 @@ export class JobManager {
                 JSON.stringify(existing.stderrArtifact) !==
                     JSON.stringify(stderrArtifact)));
         const reopenSettlement = Boolean(existing?.acknowledgedAt && completionChanged);
+        const responderLeaseId = job.responderLeaseId ?? existing?.responderLeaseId;
+        const leaseIsActive = Boolean(responderLeaseId &&
+            this.responderLeases.get(job.ownerSessionId) === responderLeaseId);
         const notification = {
             id: existing?.id ??
                 `completion:${createHash("sha256").update(`${job.ownerSessionId}\0${job.id}\0${job.startedAt}`).digest("hex").slice(0, 24)}`,
@@ -320,6 +396,7 @@ export class JobManager {
             ...(job.exitCode !== undefined ? { exitCode: job.exitCode } : {}),
             ...(job.signal !== undefined ? { signal: job.signal } : {}),
             ...(job.monitor !== undefined ? { monitor: job.monitor } : {}),
+            ...(responderLeaseId ? { responderLeaseId } : {}),
             ...(existing?.deliveredAt ? { deliveredAt: existing.deliveredAt } : {}),
             ...((existing?.analyzedAt ?? existing?.acknowledgedAt)
                 ? { analyzedAt: existing?.analyzedAt ?? existing?.acknowledgedAt }
@@ -327,6 +404,12 @@ export class JobManager {
             ...(!reopenSettlement && existing?.acknowledgedAt
                 ? { acknowledgedAt: existing.acknowledgedAt }
                 : {}),
+            ...(existing?.settledAt ? { settledAt: existing.settledAt } : {}),
+            ...(!leaseIsActive
+                ? { archivedAt: existing?.archivedAt ?? endedAt }
+                : existing?.archivedAt
+                    ? { archivedAt: existing.archivedAt }
+                    : {}),
         };
         const updated = Boolean(existing && JSON.stringify(existing) !== JSON.stringify(notification));
         this.notifications.set(notification.id, notification);
@@ -347,6 +430,7 @@ export class JobManager {
         const correctsLost = job.status === "lost" && status !== "lost";
         if (this.isTerminalStatus(job.status) && !correctsLost) {
             const completion = this.ensureCompletionNotification(job);
+            this.scheduleTaskSettlement(job);
             if ((!completion.created && !completion.updated) ||
                 !completion.notification) {
                 return true;
@@ -363,7 +447,8 @@ export class JobManager {
             return persisted;
         }
         const finalization = (async () => {
-            this.clearJobDeadline(job.id);
+            this.clearAuthorizationTimer(job.id);
+            this.livenessMisses.delete(job.id);
             const streamsFlushed = await this.closeWriters(job.id);
             job.status = streamsFlushed ? status : "failed";
             if (details.exitCode !== undefined)
@@ -377,6 +462,7 @@ export class JobManager {
             this.abortControllers.delete(job.id);
             this.processes.delete(job.id);
             const completion = this.ensureCompletionNotification(job);
+            this.scheduleTaskSettlement(job);
             this.pruneTerminalJobs();
             const persisted = this.persistSync();
             if (!persisted)
@@ -402,19 +488,40 @@ export class JobManager {
     }
     /** Reconcile a restored process that no longer has a ChildProcess close event. */
     refreshJobLiveness(job) {
-        if (!this.isLive(job) || this.processes.has(job.id))
+        if (!this.isLive(job) || this.processes.has(job.id)) {
+            this.livenessMisses.delete(job.id);
             return;
-        const identity = processIdentity(job.pid);
-        if (processAlive(job.pid) &&
-            identity &&
-            job.processIdentity &&
-            identity === job.processIdentity) {
+        }
+        // Primary signal is the pid itself. If the process is alive we keep the job
+        // running and only ever declare "lost" on a PROVEN pid reuse (both the
+        // stored and the current identity are present AND differ). An identity read
+        // that fails or returns nothing is "unknown", never "dead" — treating it as
+        // dead is exactly what flipped live jobs to lost mid-run.
+        if (processAlive(job.pid)) {
+            const identity = processIdentity(job.pid);
+            const provenReuse = Boolean(identity && job.processIdentity && identity !== job.processIdentity);
+            if (!provenReuse) {
+                this.livenessMisses.delete(job.id);
+                return;
+            }
+        }
+        // The process looks gone (or is a proven pid reuse). Require the miss to
+        // persist across a grace window before finalizing — a single transient
+        // hiccup must not kill a job whose real close event is still in flight.
+        const nowMs = Date.now();
+        const firstMiss = this.livenessMisses.get(job.id);
+        if (firstMiss === undefined) {
+            this.livenessMisses.set(job.id, nowMs);
             return;
         }
+        if (nowMs - firstMiss < LIVENESS_LOST_GRACE_MS)
+            return;
+        this.livenessMisses.delete(job.id);
         job.status = "lost";
         job.endedAt = new Date().toISOString();
-        this.clearJobDeadline(job.id);
+        this.clearAuthorizationTimer(job.id);
         const completion = this.ensureCompletionNotification(job);
+        this.scheduleTaskSettlement(job);
         this.pruneTerminalJobs();
         if (!this.persistSync())
             this.scheduleRegistryRetry();
@@ -428,22 +535,54 @@ export class JobManager {
             });
         }
     }
-    /** Arm or restore a persisted finite-job deadline. */
-    scheduleJobDeadline(job) {
-        this.clearJobDeadline(job.id);
-        if (!job.timeoutAt || !this.isLive(job))
-            return;
-        const timeoutAt = Date.parse(job.timeoutAt);
-        if (!Number.isFinite(timeoutAt))
+    scheduleTaskSettlement(job, delayMs = 0) {
+        if (!job.responder || !this.isTerminalStatus(job.status))
             return;
+        const existing = this.settlementTimers.get(job.id);
+        if (existing)
+            clearTimeout(existing);
         const timer = setTimeout(() => {
-            this.deadlineTimers.delete(job.id);
-            this.refreshJobLiveness(job);
-            if (this.isLive(job))
-                void this.stopJob(job.id, { graceMs: 1_000 });
-        }, Math.max(0, timeoutAt - Date.now()));
+            this.settlementTimers.delete(job.id);
+            void import("../store/responder-settlement.js")
+                .then(({ settleResponderJob }) => settleResponderJob({ ...job }))
+                .then((result) => {
+                if (result === "applied" || result === "noop") {
+                    this.settlementAttempts.delete(job.id);
+                    const notification = this.notificationForJob(job.id);
+                    if (notification && !notification.settledAt) {
+                        notification.settledAt = new Date().toISOString();
+                        if (!this.persistSync())
+                            this.scheduleRegistryRetry();
+                        this.emit({
+                            type: "notification",
+                            jobId: job.id,
+                            notificationId: notification.id,
+                        });
+                    }
+                    return;
+                }
+                const attempt = (this.settlementAttempts.get(job.id) ?? 0) + 1;
+                this.settlementAttempts.set(job.id, attempt);
+                if (attempt < 8) {
+                    this.scheduleTaskSettlement(job, Math.min(5_000, 50 * 2 ** attempt));
+                }
+                else {
+                    this.settlementAttempts.delete(job.id);
+                }
+            })
+                .catch(() => {
+                const attempt = (this.settlementAttempts.get(job.id) ?? 0) + 1;
+                this.settlementAttempts.set(job.id, attempt);
+                if (attempt < 8) {
+                    this.scheduleTaskSettlement(job, Math.min(5_000, 50 * 2 ** attempt));
+                }
+                else {
+                    this.settlementAttempts.delete(job.id);
+                }
+            });
+        }, delayMs);
         timer.unref?.();
-        this.deadlineTimers.set(job.id, timer);
+        this.settlementTimers.set(job.id, timer);
     }
     /**
      * Register an in-flight tool for stall tracking only.
@@ -476,7 +615,7 @@ export class JobManager {
         this.abortControllers.delete(id);
         this.processes.delete(id);
         if (!this.isLive(job))
-            this.clearJobDeadline(id);
+            this.clearAuthorizationTimer(id);
         if (!this.isDurable(job) && !this.isLive(job)) {
             this.jobs.delete(id);
             this.emit({ type: "job", jobId: id });
@@ -558,10 +697,8 @@ export class JobManager {
             ...(options?.wakeOnCompletion !== undefined ? { wakeOnCompletion: options.wakeOnCompletion } : {}),
             ...(options?.responder !== undefined ? { responder: options.responder } : {}),
             ...(monitor !== undefined ? { monitor } : {}),
-            ...(options?.timeoutMs !== undefined
-                ? {
-                    timeoutAt: new Date(Date.now() + Math.max(1_000, Math.floor(options.timeoutMs))).toISOString(),
-                }
+            ...(options?.responderLeaseId
+                ? { responderLeaseId: options.responderLeaseId }
                 : {}),
             ...(options?.authorization ? { authorization: options.authorization } : {}),
         };
@@ -670,12 +807,7 @@ export class JobManager {
             job.processIdentity = processIdentity(child.pid);
             this.processes.set(id, child);
             this.writers.set(id, { stdout, stderr });
-            const expiresAt = options?.authorization?.expiresAt ? Date.parse(options.authorization.expiresAt) : Number.NaN;
-            const expiryTimer = Number.isFinite(expiresAt) && expiresAt > Date.now()
-                ? setTimeout(() => { void this.stopJob(id, { graceMs: 1_000 }); }, expiresAt - Date.now())
-                : undefined;
-            expiryTimer?.unref?.();
-            this.scheduleJobDeadline(job);
+            this.scheduleAuthorizationExpiry(job);
             let lastProgressFlush = 0;
             let progressDirty = false;
             let progressTimer;
@@ -725,8 +857,6 @@ export class JobManager {
             child.stdout?.on("data", (chunk) => recordOutput(stdout, chunk));
             child.stderr?.on("data", (chunk) => recordOutput(stderr, chunk));
             child.on("close", (code, signal) => {
-                if (expiryTimer)
-                    clearTimeout(expiryTimer);
                 stopProgressFlush();
                 const status = signal ? "killed" : code === 0 ? "exited" : "failed";
                 void this.finalizeJob(job, status, {
@@ -735,8 +865,6 @@ export class JobManager {
                 });
             });
             child.on("error", (error) => {
-                if (expiryTimer)
-                    clearTimeout(expiryTimer);
                 stopProgressFlush();
                 const code = error.code ?? "UNKNOWN";
                 try {
@@ -926,6 +1054,47 @@ export class JobManager {
     pendingNotifications(sessionId) {
         return this.getPendingNotifications(sessionId);
     }
+    claimNextResponderNotification(sessionId, leaseId) {
+        if (this.responderLeases.get(sessionId) !== leaseId)
+            return undefined;
+        const archivedAt = new Date().toISOString();
+        let archived = false;
+        for (const notification of this.notifications.values()) {
+            if (notification.ownerSessionId === sessionId &&
+                !notification.acknowledgedAt &&
+                notification.responderLeaseId !== leaseId &&
+                !notification.archivedAt) {
+                notification.archivedAt = archivedAt;
+                archived = true;
+            }
+        }
+        const notification = [...this.notifications.values()]
+            .filter((candidate) => candidate.ownerSessionId === sessionId &&
+            candidate.responderLeaseId === leaseId &&
+            !candidate.archivedAt &&
+            !candidate.analyzedAt &&
+            !candidate.acknowledgedAt)
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt))[0];
+        if (!notification) {
+            if (archived && !this.persistSync())
+                this.scheduleRegistryRetry();
+            return undefined;
+        }
+        const previous = notification.deliveredAt;
+        notification.deliveredAt ??= new Date().toISOString();
+        if (!this.persistSync()) {
+            notification.deliveredAt = previous;
+            return undefined;
+        }
+        if (archived)
+            this.persistSync();
+        this.emit({
+            type: "notification",
+            jobId: notification.jobId,
+            notificationId: notification.id,
+        });
+        return notification;
+    }
     markDelivered(notificationId) {
         const notification = this.notifications.get(notificationId);
         if (!notification)
@@ -1008,6 +1177,7 @@ export class JobManager {
         if (metadata.responder !== undefined)
             job.responder = metadata.responder;
         const completion = this.ensureCompletionNotification(job);
+        this.scheduleTaskSettlement(job);
         if (completion.notification) {
             if (metadata.taskId !== undefined)
                 completion.notification.taskId = metadata.taskId;
@@ -1168,7 +1338,7 @@ export class JobManager {
         const childClose = child
             ? new Promise((resolve) => child.once("close", () => resolve()))
             : undefined;
-        this.clearJobDeadline(id);
+        this.clearAuthorizationTimer(id);
         const previousStatus = job.status;
         const previousWakeOnCompletion = job.wakeOnCompletion;
         if (options?.suppressWake)
@@ -1177,8 +1347,7 @@ export class JobManager {
         if (!this.persistSync()) {
             job.status = previousStatus;
             job.wakeOnCompletion = previousWakeOnCompletion;
-            if (!job.timeoutAt || Date.parse(job.timeoutAt) > Date.now())
-                this.scheduleJobDeadline(job);
+            this.scheduleAuthorizationExpiry(job);
             return { ok: false, output: `Failed to persist stop state for job "${id}"; no signal was sent.`, exitCode: 1 };
         }
         this.emit({ type: "job", jobId: id });
@@ -1203,8 +1372,7 @@ export class JobManager {
         };
         const restoreRunning = () => {
             job.status = "running";
-            if (!job.timeoutAt || Date.parse(job.timeoutAt) > Date.now())
-                this.scheduleJobDeadline(job);
+            this.scheduleAuthorizationExpiry(job);
             this.persistSync();
             this.emit({ type: "job", jobId: id });
         };
@@ -1374,6 +1542,24 @@ export class JobManager {
     /** Drop stale terminal durable jobs and all leftover ephemeral rows. */
     pruneTerminalJobs() {
         const now = Date.now();
+        const archivedUnsettled = [...this.notifications.values()]
+            .filter((notification) => Boolean(notification.archivedAt) &&
+            !notification.acknowledgedAt &&
+            !notification.settledAt)
+            .sort((left, right) => (right.archivedAt ?? right.createdAt).localeCompare(left.archivedAt ?? left.createdAt));
+        for (const [index, notification] of archivedUnsettled.entries()) {
+            const archivedAt = Date.parse(notification.archivedAt ?? notification.endedAt ?? notification.createdAt);
+            const expired = Number.isFinite(archivedAt) &&
+                now - archivedAt > ARCHIVED_UNSETTLED_MAX_AGE_MS;
+            if (index < MAX_ARCHIVED_UNSETTLED_NOTIFICATIONS && !expired)
+                continue;
+            this.notifications.delete(notification.id);
+            const timer = this.settlementTimers.get(notification.jobId);
+            if (timer)
+                clearTimeout(timer);
+            this.settlementTimers.delete(notification.jobId);
+            this.settlementAttempts.delete(notification.jobId);
+        }
         for (const [id, notification] of this.notifications) {
             const job = this.jobs.get(notification.jobId);
             if (!job ||
@@ -1392,8 +1578,11 @@ export class JobManager {
             if (this.isLive(job))
                 continue;
             const notification = this.notificationForJob(job.id);
-            if (notification && !notification.acknowledgedAt)
+            if (notification &&
+                !notification.acknowledgedAt &&
+                !(notification.archivedAt && notification.settledAt)) {
                 continue;
+            }
             const ended = job.endedAt ? Date.parse(job.endedAt) : Date.parse(job.startedAt);
             if (Number.isFinite(ended) && now - ended > TERMINAL_JOB_MAX_AGE_MS) {
                 this.jobs.delete(id);
@@ -1433,6 +1622,9 @@ export class JobManager {
                     if (notifiedJobs.has(notification.jobId))
                         continue;
                     notifiedJobs.add(notification.jobId);
+                    if (!notification.acknowledgedAt && !notification.archivedAt) {
+                        notification.archivedAt = new Date().toISOString();
+                    }
                     this.notifications.set(notification.id, notification);
                 }
             }
@@ -1441,8 +1633,14 @@ export class JobManager {
                     continue;
                 job.kind = "durable";
                 if (["starting", "running", "stopping"].includes(job.status)) {
-                    const identity = processIdentity(job.pid);
-                    if (!processAlive(job.pid) || !identity || !job.processIdentity || identity !== job.processIdentity) {
+                    const alive = processAlive(job.pid);
+                    const identity = alive ? processIdentity(job.pid) : undefined;
+                    // Only declare lost when the process is truly gone, or when we can
+                    // PROVE a pid reuse (stored + current identity both known and
+                    // different). An alive pid whose identity is unknown/unreadable is
+                    // kept running — never kill a live process over a failed `ps` read.
+                    const provenReuse = Boolean(identity && job.processIdentity && identity !== job.processIdentity);
+                    if (!alive || provenReuse) {
                         job.status = "lost";
                         job.endedAt = new Date().toISOString();
                     }
@@ -1451,9 +1649,11 @@ export class JobManager {
                         job.heartbeatAt = new Date().toISOString();
                     }
                 }
+                delete job.timeoutAt;
                 this.jobs.set(job.id, job);
                 this.ensureCompletionNotification(job);
-                this.scheduleJobDeadline(job);
+                this.scheduleAuthorizationExpiry(job);
+                this.scheduleTaskSettlement(job);
             }
             for (const [id, notification] of this.notifications) {
                 const job = this.jobs.get(notification.jobId);