@north-light/crouter 0.3.282 → 0.3.283

package/dist/daemon/crtrd.js

@@ -50,6 +50,7 @@ import { listNodes, migrateLegacyPidIdentities, } from '../core/canvas/index.js'
 import { createApiServer } from './api/server.js';
 import { reconcileUndeliveredTickets } from './human/sweep.js';
 import { recoverRunningActionDeliveries } from '../core/canvas/human-deliveries.js';
+import { recoverRunningOutcomeDeliveries } from '../core/canvas/node-outcome-deliveries.js';
 import { sweepReviews } from './review/sweep.js';
 import { pidfilePath } from './pidfile.js';
 import { rendererWarning } from '../core/runtime/package-health.js';
@@ -57,8 +58,10 @@ import { DEFAULT_INTERVAL_MS } from './supervise-cadence.js';
 import { BrokerSupervisionReconciler } from './reconcilers/broker-supervision.js';
 import { ControllerDeathReconciler } from './reconcilers/controller-death.js';
 import { NodeLifecycleReconciler } from './reconcilers/node-lifecycle/tick.js';
+import { NodeDeadlineReconciler } from './reconcilers/node-deadline.js';
 import { CronLaneReconciler } from './reconcilers/cron-lane.js';
 import { HumanDeliveryLaneReconciler } from './reconcilers/human-delivery-lane.js';
+import { NodeOutcomeDeliveryLaneReconciler } from './reconcilers/node-outcome-delivery-lane.js';
 import { PendingReviewSubmitReconciler } from './reconcilers/pending-review-submit.js';
 import { StorageMaintenanceReconciler } from './reconcilers/storage-maintenance.js';
 import { BashDeadlineReconciler } from './reconcilers/bash-deadline.js';
@@ -272,8 +275,10 @@ const directTickLifecycle = {
 const brokerSupervision = new BrokerSupervisionReconciler();
 const controllerDeath = new ControllerDeathReconciler();
 const nodeLifecycle = new NodeLifecycleReconciler();
+const nodeDeadline = new NodeDeadlineReconciler();
 const cronLane = new CronLaneReconciler();
 const humanDeliveryLane = new HumanDeliveryLaneReconciler();
+const nodeOutcomeDeliveryLane = new NodeOutcomeDeliveryLaneReconciler();
 const pendingReviewSubmit = new PendingReviewSubmitReconciler();
 const storageMaintenance = new StorageMaintenanceReconciler();
 const bashDeadline = new BashDeadlineReconciler();
@@ -301,8 +306,12 @@ export async function superviseTick(now = Date.now(), lifecycle = directTickLife
     await brokerSupervision.run(now, { rows, fleet, lifecycle });
     controllerDeath.run(now, { rows });
     const frozen = await nodeLifecycle.run(now, { rows: [...rows, ...terminating], fleet });
+    // The universal backstop: a node past its deadline with no outcome is
+    // canceled and terminalized here, after the lifecycle pass has had its say.
+    nodeDeadline.run(now);
     cronLane.run(now, { lifecycle });
     humanDeliveryLane.run(now, { lifecycle });
+    nodeOutcomeDeliveryLane.run(now, { lifecycle });
     pendingReviewSubmit.run(now, { lifecycle });
     storageMaintenance.run(now, { lifecycle, fleet });
     await bashDeadline.run(now, { rows });
@@ -640,6 +649,9 @@ export async function runDaemon(opts = {}) {
             await reconcileUndeliveredTickets();
             // Unlike a cron one-shot, a completion is at-least-once: destinations deduplicate request IDs, so a dead daemon's running delivery is re-queued immediately.
             recoverRunningActionDeliveries(Date.now());
+            // Same at-least-once contract for node outcome deliveries: a delivery the
+            // dead daemon had marked running is re-queued rather than stranded.
+            recoverRunningOutcomeDeliveries(Date.now());
         });
         // Boot reconciliation clears stale process identities before any tick can
         // inspect them, then migrates legacy identities only with proven same-boot

package/dist/daemon/fleet.d.ts

@@ -1,13 +1,7 @@
 import { type NodeMeta } from '../core/canvas/index.js';
 import { type FleetEntry, type FleetExitStatus, type FleetRegistry } from '../core/runtime/fleet.js';
+import type { NodeOutcomeDetailV1, TerminalReason } from '../core/canvas/types.js';
 import type { HostHandle } from '../core/runtime/host.js';
-/** Surface a vehicle that never booted.
- *
- *  A pi that dies before its first session_start (so `pi_session_id` was never
- *  recorded) is invisible to its parent — the spawn returned optimistically.
- *  When the daemon observes that death it errors LOUDLY up the spine: an
- *  urgent push so the parent learns the child failed to launch instead of just
- *  seeing a silent `dead`. */
 export declare function surfaceBootFailure(meta: NodeMeta): Promise<void>;
 /** Whether a dead relaunch should resume the saved session strictly, or retry
  *  as a fresh cycle instead. A cycling attempt (cycle_pending) that dies before
@@ -69,6 +63,8 @@ export declare class DaemonFleet implements FleetRegistry {
     reserveSlot(nodeId: string): boolean;
     releaseReservation(nodeId: string): void;
     entries(): Iterable<[string, FleetEntry]>;
+    interruptForProfilePause(nodeId: string, pid?: number | undefined): void;
+    hasProfilePauseInterruption(nodeId: string): boolean;
     forget(nodeId: string): void;
     onChildExit(nodeId: string, status: FleetExitStatus): void;
     deliverExit(nodeId: string, status: FleetExitStatus): void;
@@ -78,6 +74,6 @@ export declare class DaemonFleet implements FleetRegistry {
      *  with no fleet entry. Convert that otherwise-silent strand into the same
      *  terminal outcome as a boot failure. The fresh read avoids duplicating
      *  reviveNode's launch-failure crash path. */
-    terminalizeIfStillNonTerminal(nodeId: string, event: string, error: unknown): Promise<boolean>;
+    terminalizeIfStillNonTerminal(nodeId: string, event: string, error: unknown, reason: TerminalReason, detail: NodeOutcomeDetailV1): Promise<boolean>;
     dispose(): void;
 }

package/dist/daemon/fleet.js

@@ -12,6 +12,7 @@
 // before every deliberate exit, and that durable state is robust to every kill
 // path. Codes/signals are logged for diagnostics only.
 import { getNode, getRow, subscribersOf } from '../core/canvas/index.js';
+import { isProfilePaused } from '../core/profiles/manifest.js';
 import { fullName } from '../core/canvas/labels.js';
 import { isSafeNodeId } from '../core/canvas/paths.js';
 import { transition } from '../core/runtime/lifecycle.js';
@@ -33,14 +34,16 @@ import { brokerThresholdsForDaemon } from '../core/runtime/fleet.js';
  *  When the daemon observes that death it errors LOUDLY up the spine: an
  *  urgent push so the parent learns the child failed to launch instead of just
  *  seeing a silent `dead`. */
-export async function surfaceBootFailure(meta) {
-    const body = `⚠ Spawn failed — \`${meta.name}\` (${meta.kind}) never started.\n\n` +
+function bootFailureBody(meta) {
+    return (`⚠ Spawn failed — \`${meta.name}\` (${meta.kind}) never started.\n\n` +
         `Its pi vehicle exited before the session came up (no pi_session_id was ever ` +
         `recorded), so the node produced no output. This is almost always a transient ` +
         `launch failure — e.g. resource pressure when several nodes boot at once — not ` +
         `a fault in the task itself.\n\n` +
-        `If the work still needs doing, re-spawn it; if spawns keep dying, spawn fewer at a time.`;
-    await pushUrgent(meta.node_id, body, { from: meta.node_id });
+        `If the work still needs doing, re-spawn it; if spawns keep dying, spawn fewer at a time.`);
+}
+export async function surfaceBootFailure(meta) {
+    await pushUrgent(meta.node_id, bootFailureBody(meta), { from: meta.node_id });
 }
 async function surfaceCrashLoop(meta) {
     const transportPoison = readTransportPoisonVerdict(meta.node_id);
@@ -131,6 +134,9 @@ export class DaemonFleet {
     #map = new Map();
     /** Slots claimed by launches that have not registered a broker yet. */
     #reservations = new Set();
+    /** Brokers deliberately interrupted by profile pause. This belongs to the
+     * exact child, so a resume cannot turn its later SIGTERM exit into a crash. */
+    #profilePauseInterruptions = new Set();
     #lastCapacityLogAt = Number.NEGATIVE_INFINITY;
     constructor(opts) {
         this.#epoch = opts.epoch;
@@ -191,6 +197,21 @@ export class DaemonFleet {
     entries() {
         return this.#map.entries();
     }
+    interruptForProfilePause(nodeId, pid = this.#map.get(nodeId)?.pid) {
+        if (pid === undefined)
+            return;
+        this.#profilePauseInterruptions.add(nodeId);
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // A live handle or identity-checked PID can exit between its observation
+            // and signal. The marker still makes that exact observed exit harmless.
+        }
+    }
+    hasProfilePauseInterruption(nodeId) {
+        return this.#profilePauseInterruptions.has(nodeId);
+    }
     forget(nodeId) {
         this.#map.delete(nodeId);
         this.#reservations.delete(nodeId);
@@ -217,12 +238,14 @@ export class DaemonFleet {
      *  with no fleet entry. Convert that otherwise-silent strand into the same
      *  terminal outcome as a boot failure. The fresh read avoids duplicating
      *  reviveNode's launch-failure crash path. */
-    async terminalizeIfStillNonTerminal(nodeId, event, error) {
+    async terminalizeIfStillNonTerminal(nodeId, event, error, reason, detail) {
         const meta = getNode(nodeId);
         if (meta === null || meta.status === 'done' || meta.status === 'canceled' || meta.status === 'dead')
             return false;
         await this.#terminalize(nodeId, meta, {
             event,
+            reason,
+            detail,
             wake: `Child crashed — ${fullName(meta)} (${nodeId}) could not be relaunched and is now dead. ` +
                 `It stays dead until you revive it — \`crtr node lifecycle revive ${nodeId}\`.`,
             surface: () => surfaceRecoveryFailure(meta, error),
@@ -249,6 +272,17 @@ export class DaemonFleet {
     }
     async #decideAndEnact(nodeId) {
         const meta = getNode(nodeId);
+        if (meta !== null && isProfilePaused(meta.profile_id)) {
+            clearRespawnPolicy(nodeId);
+            return 'forget';
+        }
+        // Consume one unpaused policy pass for the exact broker profile pause
+        // interrupted. The following tick owns ordinary recovery regardless of
+        // which dead-row verdict the still-recorded PID would otherwise select.
+        if (this.#profilePauseInterruptions.delete(nodeId)) {
+            clearRespawnPolicy(nodeId);
+            return 'forget';
+        }
         // Two durable witnesses mean the dead broker had a turn in flight. A dirty
         // death leaves the busy marker behind; a bounded graceful abort clears busy
         // as the run settles, then writes the clean-abort certificate. Both need the
@@ -284,6 +318,8 @@ export class DaemonFleet {
             case 'boot-failure':
                 await this.#terminalize(nodeId, meta, {
                     event: 'broker.boot.failed',
+                    reason: 'boot_failed',
+                    detail: { schema: 'crtr.node-outcome-detail/v1', message: bootFailureBody(meta) },
                     wake: `Child crashed — ${fullName(meta)} (${nodeId}) exited before its session ever came up and is now dead. ` +
                         `It stays dead until you revive it — \`crtr node lifecycle revive ${nodeId}\`.`,
                 });
@@ -328,10 +364,13 @@ export class DaemonFleet {
             ? recordRespawnPolicy(row, this.#now())
             : { failures: priorFailures, notBefore: row.respawn_not_before, exhausted: priorFailures >= MAX_RESPAWN_ATTEMPTS };
         if (attempt.exhausted) {
+            const wake = `Child crashed — ${fullName(meta)} (${nodeId}) kept dying without settling a turn (${attempt.failures} consecutive ` +
+                `launches) and is now dead. It stays dead until you revive it — \`crtr node lifecycle revive ${nodeId}\`.`;
             await this.#terminalize(nodeId, meta, {
                 event: 'broker.respawn.exhausted',
-                wake: `Child crashed — ${fullName(meta)} (${nodeId}) kept dying without settling a turn (${attempt.failures} consecutive ` +
-                    `launches) and is now dead. It stays dead until you revive it — \`crtr node lifecycle revive ${nodeId}\`.`,
+                reason: 'crash_looped',
+                detail: { schema: 'crtr.node-outcome-detail/v1', message: wake, respawn_failures: attempt.failures },
+                wake,
                 ...(meta.pi_session_id != null ? { surface: () => surfaceCrashLoop(meta) } : {}),
             });
             return;
@@ -392,7 +431,7 @@ export class DaemonFleet {
             // Launch failures terminalize inside reviveNode, but its preflight
             // refusals (for example cwd_missing) happen before that catch. Re-read
             // before terminalizing so the launch path's settled terminal row wins.
-            await this.terminalizeIfStillNonTerminal(nodeId, 'broker.respawn.refused', err);
+            await this.terminalizeIfStillNonTerminal(nodeId, 'broker.respawn.refused', err, 'launch_failed', { schema: 'crtr.node-outcome-detail/v1', message: err instanceof Error ? err.message : String(err) });
         }
     }
     /** Terminal outcome shared by table row 8 and respawn exhaustion. */
@@ -402,7 +441,7 @@ export class DaemonFleet {
             event: opts.event,
             ...(isSafeNodeId(nodeId) ? { node_id: nodeId } : { fields: { affected_node_id: nodeId } }),
         });
-        transition(nodeId, 'crash');
+        transition(nodeId, 'crash', { reason: opts.reason, outcome: { detail: opts.detail } });
         try {
             await (opts.surface ?? (() => surfaceBootFailure(meta)))();
         }

package/dist/daemon/messaging/node-message.js

@@ -9,6 +9,7 @@ import { reviveNode } from '../../core/runtime/revive.js';
 import { hasNoNaturalCycle } from '../../core/runtime/revive-all.js';
 import { ReviewOperationError } from '../../core/review/types.js';
 import { formatCard } from '../../shared/generated-context.js';
+import { isProfilePaused } from '../../core/profiles/manifest.js';
 function deliveryUnroutable(nodeId, reason) {
     throw new ReviewOperationError('delivery_unroutable', reason === 'origin_missing' ? 'message target was not found' : 'message target has no natural delivery cycle', { node_id: nodeId, reason });
 }
@@ -33,7 +34,7 @@ export async function deliverNodeMessage(args) {
     let target = getNode(args.node_id);
     if (target === null)
         deliveryUnroutable(args.node_id, 'origin_missing');
-    if (args.mode === 'interactive' && isBrokerLive(target)) {
+    if (args.mode === 'interactive' && !isProfilePaused(target.profile_id) && isBrokerLive(target)) {
         try {
             // Inbox delivery supplies the raw body as an entry in its outer inbox
             // card; only live delivery needs this message's own envelope.

package/dist/daemon/node-outcome/deliver-outcome.d.ts

@@ -0,0 +1,14 @@
+import { type OutcomeDeliveryRecord, type OutcomeDeliverySettlement } from '../../core/canvas/node-outcome-deliveries.js';
+export declare const OUTCOME_DELIVERY_TIMEOUT_MS = 120000;
+export declare const OUTCOME_DELIVERY_STDERR_TAIL_BYTES: number;
+export interface OutcomeDeliveryProcessOutcome {
+    exitCode: number | null;
+    signal: string | null;
+    timedOut: boolean;
+    spawnError?: Error;
+    stderr: string;
+}
+/** The delivery target's exit code is its complete acknowledgment protocol. */
+export declare function outcomeDeliverySettlementForOutcome(outcome: OutcomeDeliveryProcessOutcome, attempt: number, now: number): OutcomeDeliverySettlement;
+/** Spawn and settle one already-claimed outcome delivery. */
+export declare function deliverOutcome(delivery: OutcomeDeliveryRecord, claimOwner: string): Promise<void>;

package/dist/daemon/node-outcome/deliver-outcome.js

@@ -0,0 +1,155 @@
+import { spawn } from 'node:child_process';
+import { envHomeOverride } from '../../shared/env.js';
+import { outcomeDeliveryBackoffMs, settleOutcomeDelivery, } from '../../core/canvas/node-outcome-deliveries.js';
+import { killProcessGroup } from '../../core/canvas/pid.js';
+import { buildOperationalEnvBase } from '../../core/runtime/spawn-env.js';
+export const OUTCOME_DELIVERY_TIMEOUT_MS = 120_000;
+const OUTCOME_DELIVERY_KILL_GRACE_MS = 2_000;
+export const OUTCOME_DELIVERY_STDERR_TAIL_BYTES = 4 * 1024;
+/** The delivery target's exit code is its complete acknowledgment protocol. */
+export function outcomeDeliverySettlementForOutcome(outcome, attempt, now) {
+    if (outcome.spawnError !== undefined) {
+        return {
+            state: 'pending',
+            nextAttemptAt: now + outcomeDeliveryBackoffMs(attempt),
+            failure: failure('spawn_error', { message: outcome.spawnError.message, stderr: outcome.stderr }),
+        };
+    }
+    if (outcome.timedOut) {
+        return {
+            state: 'pending',
+            nextAttemptAt: now + outcomeDeliveryBackoffMs(attempt),
+            failure: failure('timeout', { ...(outcome.signal === null ? {} : { signal: outcome.signal }), stderr: outcome.stderr }),
+        };
+    }
+    if (outcome.signal !== null) {
+        return {
+            state: 'pending',
+            nextAttemptAt: now + outcomeDeliveryBackoffMs(attempt),
+            failure: failure('signal', { signal: outcome.signal, stderr: outcome.stderr }),
+        };
+    }
+    if (outcome.exitCode === 0)
+        return { state: 'accepted' };
+    if (outcome.exitCode === 78) {
+        return { state: 'permanent_failed', failure: failure('exit', { exitCode: 78, stderr: outcome.stderr }) };
+    }
+    return {
+        state: 'pending',
+        nextAttemptAt: now + outcomeDeliveryBackoffMs(attempt),
+        failure: failure('exit', { exitCode: outcome.exitCode ?? undefined, stderr: outcome.stderr }),
+    };
+}
+function failure(kind, fields) {
+    return { kind, ...fields };
+}
+function stderrTailCapture() {
+    let tail = Buffer.alloc(0);
+    return {
+        take(chunk) {
+            tail = chunk.length >= OUTCOME_DELIVERY_STDERR_TAIL_BYTES
+                ? chunk.subarray(chunk.length - OUTCOME_DELIVERY_STDERR_TAIL_BYTES)
+                : Buffer.concat([tail, chunk]).subarray(Math.max(0, tail.length + chunk.length - OUTCOME_DELIVERY_STDERR_TAIL_BYTES));
+        },
+        decode() {
+            return tail.toString('utf8');
+        },
+    };
+}
+/** The stored document is immutable; attempt is its only per-delivery mutation. */
+function documentForAttempt(document, attempt) {
+    const outcome = document;
+    const delivery = outcome.delivery;
+    return JSON.stringify({ ...outcome, delivery: { ...delivery, attempt } });
+}
+/** Spawn and settle one already-claimed outcome delivery. */
+export async function deliverOutcome(delivery, claimOwner) {
+    const stderr = stderrTailCapture();
+    let document;
+    try {
+        document = documentForAttempt(delivery.document, delivery.attempt);
+    }
+    catch (error) {
+        settle(delivery, claimOwner, outcomeDeliverySettlementForOutcome({
+            exitCode: null,
+            signal: null,
+            timedOut: false,
+            spawnError: error,
+            stderr: stderr.decode(),
+        }, delivery.attempt, Date.now()));
+        return;
+    }
+    let child;
+    try {
+        child = spawn(delivery.argv[0], delivery.argv.slice(1), {
+            cwd: delivery.cwd,
+            env: outcomeDeliveryEnv(delivery.cwd),
+            detached: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        settle(delivery, claimOwner, outcomeDeliverySettlementForOutcome({
+            exitCode: null,
+            signal: null,
+            timedOut: false,
+            spawnError: error,
+            stderr: stderr.decode(),
+        }, delivery.attempt, Date.now()));
+        return;
+    }
+    await new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let killTimer;
+        let timeout;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            // A timed-out leader can exit while a SIGTERM-ignoring group member remains.
+            if (!outcome.timedOut && killTimer !== undefined)
+                clearTimeout(killTimer);
+            child.stdin?.destroy();
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            settle(delivery, claimOwner, outcomeDeliverySettlementForOutcome(outcome, delivery.attempt, Date.now()));
+            resolve();
+        };
+        child.stdout?.on('data', () => { }); // Drain output; stdout is never a control channel.
+        child.stderr?.on('data', (chunk) => stderr.take(chunk));
+        child.stdin?.on('error', () => { }); // The child may exit before consuming stdin; its exit code is authoritative.
+        child.on('error', (error) => {
+            finish({ exitCode: null, signal: null, timedOut: false, spawnError: error, stderr: stderr.decode() });
+        });
+        child.on('exit', (exitCode, signal) => {
+            finish({ exitCode, signal, timedOut, stderr: stderr.decode() });
+        });
+        const killWithEscalation = () => {
+            if (child.pid === undefined)
+                return;
+            killProcessGroup(child.pid);
+            killTimer = setTimeout(() => killProcessGroup(child.pid, 'SIGKILL'), OUTCOME_DELIVERY_KILL_GRACE_MS);
+            killTimer.unref?.();
+        };
+        timeout = setTimeout(() => {
+            timedOut = true;
+            killWithEscalation();
+        }, OUTCOME_DELIVERY_TIMEOUT_MS);
+        timeout.unref?.();
+        child.stdin?.end(document, 'utf8');
+    });
+}
+/** Outcome targets cross the same consent boundary as every other crouter spawn. */
+function outcomeDeliveryEnv(cwd) {
+    const env = buildOperationalEnvBase({ targetCwd: cwd, targetProfileId: null });
+    const canvasHome = envHomeOverride();
+    if (canvasHome !== undefined && canvasHome !== '')
+        env['CRTR_HOME'] = canvasHome;
+    return env;
+}
+function settle(delivery, claimOwner, settlement) {
+    settleOutcomeDelivery(delivery.nodeId, delivery.attempt, claimOwner, settlement, Date.now());
+}

package/dist/daemon/park-activity.d.ts

@@ -0,0 +1,9 @@
+import type { NodeMeta } from '../core/canvas/types.js';
+import type { PendingPark } from './park-pending.js';
+/** A main-session write after parking was armed is durable evidence of live
+ * input even when the turn has since settled and the viewer detached. */
+export declare function mainSessionActivitySince(sessionFile: string | null | undefined, startedAt: number): boolean;
+/** One verdict shared by normal completion and grace expiry. A broker records
+ * accepted live input against the process-local marker before it drives Pi, so
+ * the verdict cannot race a viewer, live delivery, or durable wake. */
+export declare function shouldParkAfterSummary(nodeId: string, node: Pick<NodeMeta, 'lifecycle' | 'pi_session_file'>, pending: PendingPark): boolean;

package/dist/daemon/park-activity.js

@@ -0,0 +1,30 @@
+import { statSync } from 'node:fs';
+import { emitEvent } from '../core/events/emit.js';
+import { hasWakeMailSince } from '../core/feed/inbox.js';
+import { isBusy } from '../core/runtime/busy.js';
+import { parkEvent } from './reconcilers/live-obligation.js';
+/** A main-session write after parking was armed is durable evidence of live
+ * input even when the turn has since settled and the viewer detached. */
+export function mainSessionActivitySince(sessionFile, startedAt) {
+    if (sessionFile === null || sessionFile === undefined)
+        return false;
+    try {
+        return statSync(sessionFile).mtimeMs >= startedAt;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        emitEvent({ level: 'warn', event: 'broker.park.session_activity_scan_failed', error });
+        return true;
+    }
+}
+/** One verdict shared by normal completion and grace expiry. A broker records
+ * accepted live input against the process-local marker before it drives Pi, so
+ * the verdict cannot race a viewer, live delivery, or durable wake. */
+export function shouldParkAfterSummary(nodeId, node, pending) {
+    return !pending.activity
+        && !isBusy(nodeId)
+        && !mainSessionActivitySince(node.pi_session_file, pending.startedAt)
+        && !hasWakeMailSince(nodeId, pending.startedAt)
+        && parkEvent(nodeId, node.lifecycle) === 'park';
+}

package/dist/daemon/park-pending.d.ts

@@ -1,13 +1,18 @@
+export type PendingPark = {
+    startedAt: number;
+    activity: boolean;
+};
 /** Arm a pending park for `nodeId`. The caller delivers the parking prompt. */
 export declare function beginPendingPark(nodeId: string, now: number): void;
+/** Record main-engine input accepted while the isolated turn is in flight. */
+export declare function recordPendingParkActivity(nodeId: string): boolean;
 export declare function isPendingPark(nodeId: string): boolean;
 /** When the pending park was armed, or undefined when none is armed. */
 export declare function pendingParkStartedAt(nodeId: string): number | undefined;
-/** Delete-and-report: true only for the caller that actually took the pending
- *  park. Both the supervision tick and the settle handler run on the daemon
- *  thread with no await between their check and this call, so exactly one of
- *  them ever enacts a given park. */
-export declare function consumePendingPark(nodeId: string): boolean;
+/** Delete-and-report the pending marker. Both the supervision tick and the
+ * settle handler run on the daemon thread with no await between their check and
+ * this call, so exactly one of them ever enacts a given park. */
+export declare function consumePendingPark(nodeId: string): PendingPark | undefined;
 /** Every node with a parking turn in flight — the reconciler's sweep drops the
  *  ones whose broker has left the fleet. */
 export declare function pendingParkIds(): string[];

package/dist/daemon/park-pending.js

@@ -15,25 +15,35 @@
 // and nothing needs repair. A durable in-flight flag would instead need its own
 // reconciliation on every daemon start to avoid stranding a node that never got
 // its prompt.
-/** node id → the timestamp its parking turn was requested at. */
+/** node id → the pending parking turn and any accepted main-engine input. */
 const pending = new Map();
 /** Arm a pending park for `nodeId`. The caller delivers the parking prompt. */
 export function beginPendingPark(nodeId, now) {
-    pending.set(nodeId, now);
+    pending.set(nodeId, { startedAt: now, activity: false });
+}
+/** Record main-engine input accepted while the isolated turn is in flight. */
+export function recordPendingParkActivity(nodeId) {
+    const marker = pending.get(nodeId);
+    if (marker === undefined)
+        return false;
+    marker.activity = true;
+    return true;
 }
 export function isPendingPark(nodeId) {
     return pending.has(nodeId);
 }
 /** When the pending park was armed, or undefined when none is armed. */
 export function pendingParkStartedAt(nodeId) {
-    return pending.get(nodeId);
+    return pending.get(nodeId)?.startedAt;
 }
-/** Delete-and-report: true only for the caller that actually took the pending
- *  park. Both the supervision tick and the settle handler run on the daemon
- *  thread with no await between their check and this call, so exactly one of
- *  them ever enacts a given park. */
+/** Delete-and-report the pending marker. Both the supervision tick and the
+ * settle handler run on the daemon thread with no await between their check and
+ * this call, so exactly one of them ever enacts a given park. */
 export function consumePendingPark(nodeId) {
-    return pending.delete(nodeId);
+    const marker = pending.get(nodeId);
+    if (marker !== undefined)
+        pending.delete(nodeId);
+    return marker;
 }
 /** Every node with a parking turn in flight — the reconciler's sweep drops the
  *  ones whose broker has left the fleet. */

package/dist/daemon/reconcilers/bash-deadline.js

@@ -5,6 +5,7 @@ import { cancelCronsOnWake } from '../../core/canvas/crons.js';
 import { appendInbox } from '../../core/feed/inbox.js';
 import { emitEvent } from '../../core/events/emit.js';
 import { operationIdContext } from '../../core/events/operation-id.js';
+import { isProfilePaused } from '../../core/profiles/manifest.js';
 // How often the deadline scan runs. The valve arms a 60s default deadline, so a
 // few seconds of enforcement latency is immaterial; scanning every tick would
 // readdir every node's jobs dir needlessly.
@@ -28,6 +29,11 @@ export class BashDeadlineReconciler {
         for (const row of ctx.rows) {
             if (row.status === 'dead')
                 continue;
+            // A paused profile's node cannot claim anything: pause stopped its broker.
+            // Enforcing the window here would cancel the job for a silence the pause
+            // imposed, so the deadline waits and resume credits it the same interval.
+            if (isProfilePaused(row.profile_id))
+                continue;
             const dir = contextDir(row.node_id);
             let expired;
             try {

package/dist/daemon/reconcilers/broker-supervision.d.ts

@@ -61,16 +61,12 @@ export declare class BrokerSupervisionReconciler {
     run(now: number, ctx: BrokerSupervisionContext): Promise<void>;
     /** Every condition that resets the unattended clock EXCEPT `isBusy` — the
      *  node is unavailable to park, attended, or has work waiting. Short-circuits
-     *  in cost order so the common tick does no file reads it can avoid.
-     *  Evaluated for a pending park too, where a busy engine is precisely what is
-     *  expected (it is writing the summary) and every other hit aborts. */
+     *  in cost order so the common tick does no file reads it can avoid. */
     private parkResetCondition;
     private handleUnattendedParking;
     /** Deliver the parking prompt over the live broker's serialized frame loop.
-     *  Two outcomes cancel the park immediately: an unreachable broker (nothing
-     *  live to summarize with) falls through to the degraded enactment, and a
-     *  `steer` route means a turn started between the idle gate and the frame, so
-     *  the node is working again and its clock simply restarts. */
+     * An unreachable broker falls through to degraded parking; either prompt route
+     * starts the same isolated turn, so a concurrent main turn stays passive. */
     private requestParkSummary;
     private warnOverCapInTmux;
     private handleYieldStall;