@north-light/crouter 0.3.317 → 0.3.319

package/dist/daemon/reconcilers/node-lifecycle/freeze-lane.js

@@ -1,172 +1 @@
-// freeze-lane.ts — who gets the free slots, in what order, and what happens to
-// everyone else.
-//
-// The tick hands this lane every row that wants execution and has no engine.
-// Enactment is strictly sequential on the daemon's serial work lane, so the
-// ledger inside `headlessBrokerHost.launch` hands slots out in exactly the
-// order this lane enacts: ordering IS the allocation policy, and no candidate
-// needs to pre-reserve anything. A candidate that finds the ledger full freezes
-// (`reviveNode` with `capacity: 'freeze'` is the single freeze writer) and waits
-// for the next tick.
-import { clearFrozen, getNode, getRow, subscribersOf, } from '../../../core/canvas/index.js';
-import { fullName } from '../../../core/canvas/labels.js';
-import { isSafeNodeId } from '../../../core/canvas/paths.js';
-import { emitEvent } from '../../../core/events/emit.js';
-import { operationIdContext } from '../../../core/events/operation-id.js';
-import { acknowledgedNodeMailCount } from '../../../core/canvas/deliveries.js';
-import { fanDoctrineWake } from '../../../core/runtime/close.js';
-import { transition } from '../../../core/runtime/lifecycle.js';
-import { reviveNode } from '../../../core/runtime/revive.js';
-import { hasPendingWake } from '../live-obligation.js';
-// Idle-release delivery retry cap. The counter is keyed on acknowledged
-// delivery progress, not row-state residency or pid liveness: a transiently
-// live broker does not prove that a destination received its mail.
-const IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS = 6;
-const IDLE_RELEASE_RELAUNCH_MAX_BACKOFF_MS = 10 * 60_000;
-const IDLE_RELEASE_RELAUNCH_BASE_MS = 20_000;
-/** Which tier a candidate competes in. A row that was launched and never
- *  settled a turn drops to tier 2: it already spent a slot without producing
- *  anything, so it must not keep outranking the mail it stalled behind. A row
- *  that never launched at all has spent nothing and stays tier 1. */
-export function thawTier(row, pendingWake) {
-    if (pendingWake)
-        return 2;
-    const launched = row.launched_at;
-    if (launched == null)
-        return 1;
-    const settled = row.last_settled_at;
-    if (settled == null)
-        return 2;
-    return Date.parse(settled) > Date.parse(launched) ? 1 : 2;
-}
-/** Thaw order: tier first, then longest-frozen first. A candidate with no
- *  `frozen_at` has not waited at all and sorts last within its tier. */
-export function compareThaw(a, b) {
-    if (a.tier !== b.tier)
-        return a.tier - b.tier;
-    const af = a.row.frozen_at;
-    const bf = b.row.frozen_at;
-    if (af == null)
-        return bf == null ? 0 : 1;
-    if (bf == null)
-        return -1;
-    return Date.parse(af) - Date.parse(bf);
-}
-export class FreezeLaneReconciler {
-    relaunchState = new Map();
-    /** End a stuck-delivery episode the tick decided is over — the node's profile
-     * paused, or it has no wake-worthy mail left. */
-    endEpisode(nodeId) {
-        this.relaunchState.delete(nodeId);
-    }
-    async run(now, ctx) {
-        const entries = ctx.candidates.map((candidate) => ({
-            ...candidate,
-            tier: thawTier(candidate.row, hasPendingWake(candidate.row.node_id)),
-        }));
-        entries.sort(compareThaw);
-        const counts = { stalled: 0, waitingOnMail: 0 };
-        for (const entry of entries) {
-            const outcome = await operationIdContext.fresh(() => this.enact(now, entry, ctx.fleet));
-            if (outcome !== 'frozen')
-                continue;
-            if (entry.tier === 1)
-                counts.stalled += 1;
-            else
-                counts.waitingOnMail += 1;
-        }
-        return counts;
-    }
-    async enact(now, entry, fleet) {
-        const id = entry.row.node_id;
-        try {
-            if (entry.enact === 'thaw')
-                return await this.enactThaw(entry.row);
-            if (entry.enact === 'idle-release')
-                return await this.enactIdleRelease(now, entry.row);
-            // The SAME policy table an exit event runs, so tick recovery and exit
-            // recovery can never diverge. It relaunches through
-            // `reviveNode(capacity: 'freeze')`, which freezes the row when the ledger
-            // is full — the outcome this lane reports as saturation.
-            await fleet.applyDeadRowPolicy(id);
-            if (fleet.has(id))
-                return 'launched';
-            return getRow(id)?.frozen_at != null ? 'frozen' : 'skipped';
-        }
-        catch (err) {
-            emitEvent({
-                level: 'error',
-                event: 'node.lifecycle.enact_failed',
-                ...(isSafeNodeId(id) ? { node_id: id } : {}),
-                error: err,
-                fields: { ...(isSafeNodeId(id) ? {} : { affected_node_id: id }), enact: entry.enact },
-            });
-            return 'skipped';
-        }
-    }
-    async enactThaw(row) {
-        if (row.lifecycle === 'resident' && getNode(row.node_id)?.pi_session_id != null && !hasPendingWake(row.node_id)) {
-            transition(row.node_id, 'release');
-            clearFrozen(row.node_id);
-            return 'skipped';
-        }
-        return (await reviveNode(row.node_id, { resume: true, capacity: 'freeze', recovery: true })).outcome === 'frozen'
-            ? 'frozen'
-            : 'launched';
-    }
-    async enactIdleRelease(now, row) {
-        const id = row.node_id;
-        const acknowledgedCount = acknowledgedNodeMailCount(id);
-        const prior = this.relaunchState.get(id);
-        const deliveryProgressed = prior === undefined || prior.acknowledgedCount !== acknowledgedCount;
-        const attempts = deliveryProgressed ? 0 : prior.attempts;
-        if (attempts >= IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS) {
-            this.relaunchState.delete(id);
-            emitEvent({
-                level: 'warn',
-                event: 'broker.idle_release.exhausted',
-                ...(isSafeNodeId(id) ? { node_id: id } : {}),
-                fields: {
-                    ...(isSafeNodeId(id) ? {} : { affected_node_id: id }),
-                    attempts,
-                    max_attempts: IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS,
-                },
-            });
-            transition(id, 'crash', {
-                reason: 'launch_failed',
-                outcome: {
-                    detail: {
-                        schema: 'crtr.node-outcome-detail/v1',
-                        respawn_failures: attempts,
-                    },
-                },
-            });
-            fanDoctrineWake(id, subscribersOf(id), `Child crashed — ${fullName(row)} (${id}) failed to relaunch after ${attempts} attempts while trying to ` +
-                `deliver a pending inbox message (no delivery progress across any attempt), and is now dead. It stays ` +
-                `dead until you revive it — \`crtr node lifecycle revive ${id}\`.`, { reason: 'child-crashed', child: id });
-            return 'skipped';
-        }
-        const lastAttempt = deliveryProgressed ? undefined : prior?.lastAttempt;
-        const backoff = Math.min(IDLE_RELEASE_RELAUNCH_BASE_MS * 2 ** attempts, IDLE_RELEASE_RELAUNCH_MAX_BACKOFF_MS);
-        if (lastAttempt !== undefined && now - lastAttempt < backoff)
-            return 'skipped';
-        // A relaunch the broker cap froze got no slot and therefore proved nothing
-        // about this delivery, so it must not spend an attempt: only a launch that
-        // actually happened advances the episode toward exhaustion.
-        if ((await reviveNode(id, { resume: true, capacity: 'freeze' })).outcome === 'frozen')
-            return 'frozen';
-        this.relaunchState.set(id, { acknowledgedCount, attempts: attempts + 1, lastAttempt: now });
-        emitEvent({
-            level: 'info',
-            event: 'broker.revive.idle_release',
-            ...(isSafeNodeId(id) ? { node_id: id } : {}),
-            attempt: attempts + 1,
-            fields: {
-                ...(isSafeNodeId(id) ? {} : { affected_node_id: id }),
-                attempts: attempts + 1,
-                max_attempts: IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS,
-            },
-        });
-        return 'launched';
-    }
-}
+var w=Object.defineProperty;var d=(i,t)=>w(i,"name",{value:t,configurable:!0});import{clearFrozen as v,getNode as E,getRow as y,subscribersOf as g}from"../../../core/canvas/index.js";import{fullName as A}from"../../../core/canvas/labels.js";import{isSafeNodeId as s}from"../../../core/canvas/paths.js";import{emitEvent as c}from"../../../core/events/emit.js";import{operationIdContext as k}from"../../../core/events/operation-id.js";import{acknowledgedNodeMailCount as z}from"../../../core/canvas/deliveries.js";import{fanDoctrineWake as S}from"../../../core/runtime/close.js";import{transition as p}from"../../../core/runtime/lifecycle.js";import{reviveNode as m}from"../../../core/runtime/revive.js";import{hasPendingWake as _}from"../live-obligation.js";const f=6,R=10*6e4,L=2e4;function M(i,t){if(t)return 2;const r=i.launched_at;if(r==null)return 1;const e=i.last_settled_at;return e==null?2:Date.parse(e)>Date.parse(r)?1:2}d(M,"thawTier");function C(i,t){if(i.tier!==t.tier)return i.tier-t.tier;const r=i.row.frozen_at,e=t.row.frozen_at;return r==null?e==null?0:1:e==null?-1:Date.parse(r)-Date.parse(e)}d(C,"compareThaw");class U{static{d(this,"FreezeLaneReconciler")}relaunchState=new Map;endEpisode(t){this.relaunchState.delete(t)}async run(t,r){const e=r.candidates.map(a=>({...a,tier:M(a.row,_(a.row.node_id))}));e.sort(C);const n={stalled:0,waitingOnMail:0};for(const a of e)await k.fresh(()=>this.enact(t,a,r.fleet))==="frozen"&&(a.tier===1?n.stalled+=1:n.waitingOnMail+=1);return n}async enact(t,r,e){const n=r.row.node_id;try{return r.enact==="thaw"?await this.enactThaw(r.row):r.enact==="idle-release"?await this.enactIdleRelease(t,r.row):(await e.applyDeadRowPolicy(n),e.has(n)?"launched":y(n)?.frozen_at!=null?"frozen":"skipped")}catch(a){return c({level:"error",event:"node.lifecycle.enact_failed",...s(n)?{node_id:n}:{},error:a,fields:{...s(n)?{}:{affected_node_id:n},enact:r.enact}}),"skipped"}}async enactThaw(t){return t.lifecycle==="resident"&&E(t.node_id)?.pi_session_id!=null&&!_(t.node_id)?(p(t.node_id,"release"),v(t.node_id),"skipped"):(await m(t.node_id,{resume:!0,capacity:"freeze",recovery:!0})).outcome==="frozen"?"frozen":"launched"}async enactIdleRelease(t,r){const e=r.node_id,n=z(e),a=this.relaunchState.get(e),l=a===void 0||a.acknowledgedCount!==n,o=l?0:a.attempts;if(o>=f)return this.relaunchState.delete(e),c({level:"warn",event:"broker.idle_release.exhausted",...s(e)?{node_id:e}:{},fields:{...s(e)?{}:{affected_node_id:e},attempts:o,max_attempts:f}}),p(e,"crash",{reason:"launch_failed",outcome:{detail:{schema:"crtr.node-outcome-detail/v1",respawn_failures:o}}}),S(e,g(e),`Child crashed \u2014 ${A(r)} (${e}) failed to relaunch after ${o} attempts while trying to deliver a pending inbox message (no delivery progress across any attempt), and is now dead. It stays dead until you revive it \u2014 \`crtr node lifecycle revive ${e}\`.`,{reason:"child-crashed",child:e}),"skipped";const u=l?void 0:a?.lastAttempt,h=Math.min(L*2**o,R);return u!==void 0&&t-u<h?"skipped":(await m(e,{resume:!0,capacity:"freeze"})).outcome==="frozen"?"frozen":(this.relaunchState.set(e,{acknowledgedCount:n,attempts:o+1,lastAttempt:t}),c({level:"info",event:"broker.revive.idle_release",...s(e)?{node_id:e}:{},attempt:o+1,fields:{...s(e)?{}:{affected_node_id:e},attempts:o+1,max_attempts:f}}),"launched")}}export{U as FreezeLaneReconciler,C as compareThaw,M as thawTier};

package/dist/daemon/reconcilers/node-lifecycle/respawn-policy.js

@@ -1,59 +1 @@
-import { recordRespawnAttempt } from '../../../core/canvas/index.js';
-export const MAX_RESPAWN_ATTEMPTS = 6;
-const RESPAWN_BACKOFF_BASE_MS = 5_000;
-const RESPAWN_BACKOFF_MAX_MS = 10 * 60_000;
-/** How long an offline box waits before re-testing the network and relaunching.
- *  Flat, not exponential: this is not a failure sequence being paced, it is a
- *  wait for a condition outside the node — the same "my wifi is back" gate the
- *  broker's connection-fault retry uses, sampled less often because each sample
- *  here can cost a whole broker launch. */
-export const OFFLINE_RESPAWN_RETRY_MS = 30_000;
-export function respawnBackoffMs(consecutiveFailures) {
-    if (consecutiveFailures <= 0)
-        return 0;
-    return Math.min(RESPAWN_BACKOFF_BASE_MS * 2 ** (consecutiveFailures - 1), RESPAWN_BACKOFF_MAX_MS);
-}
-/** Whether a durable backoff still holds this row back from a relaunch. */
-export function isInBackoff(row, now) {
-    const notBefore = row.respawn_not_before;
-    if (notBefore == null)
-        return false;
-    const at = Date.parse(notBefore);
-    return Number.isFinite(at) && now < at;
-}
-/** The only respawn-failure policy: progress since launch clears the sequence;
- * every other missing-engine observation advances it and records its backoff. */
-export function decideRespawnAttempt(row, now) {
-    const settledAt = row.last_settled_at == null ? Number.NaN : Date.parse(row.last_settled_at);
-    const launchedAt = row.launched_at == null ? Number.NaN : Date.parse(row.launched_at);
-    if (Number.isFinite(settledAt) && Number.isFinite(launchedAt) && settledAt > launchedAt) {
-        return { failures: 0, notBefore: null, exhausted: false };
-    }
-    const failures = (row.respawn_failures ?? 0) + 1;
-    return {
-        failures,
-        notBefore: new Date(now + respawnBackoffMs(failures)).toISOString(),
-        exhausted: failures >= MAX_RESPAWN_ATTEMPTS,
-    };
-}
-/** Hold a relaunch while the box has no network, WITHOUT advancing the failure
- *  sequence. An outage makes every launch fail identically, so counting those
- *  launches spends the whole respawn budget on a condition the node did not
- *  cause and cannot fix — the node terminalizes minutes into an outage and only
- *  a human revive brings it back. Re-arming instead parks it: the row stays
- *  active, the tick re-enters this policy after the window, and the first
- *  launch made once the network returns resumes the interrupted turn. */
-export function deferRespawnWhileOffline(nodeId, failures, now) {
-    const notBefore = new Date(now + OFFLINE_RESPAWN_RETRY_MS).toISOString();
-    recordRespawnAttempt(nodeId, { failures, notBefore });
-    return { failures, notBefore, exhausted: false };
-}
-/** Persist the policy decision through the daemon-only canvas writer. */
-export function recordRespawnPolicy(row, now) {
-    const attempt = decideRespawnAttempt(row, now);
-    recordRespawnAttempt(row.node_id, { failures: attempt.failures, notBefore: attempt.notBefore });
-    return attempt;
-}
-export function clearRespawnPolicy(nodeId) {
-    recordRespawnAttempt(nodeId, { failures: 0, notBefore: null });
-}
+var f=Object.defineProperty;var o=(e,n)=>f(e,"name",{value:n,configurable:!0});import{recordRespawnAttempt as s}from"../../../core/canvas/index.js";const u=6,i=5e3,l=10*6e4,c=3e4;function _(e){return e<=0?0:Math.min(i*2**(e-1),l)}o(_,"respawnBackoffMs");function N(e,n){const t=e.respawn_not_before;if(t==null)return!1;const r=Date.parse(t);return Number.isFinite(r)&&n<r}o(N,"isInBackoff");function p(e,n){const t=e.last_settled_at==null?Number.NaN:Date.parse(e.last_settled_at),r=e.launched_at==null?Number.NaN:Date.parse(e.launched_at);if(Number.isFinite(t)&&Number.isFinite(r)&&t>r)return{failures:0,notBefore:null,exhausted:!1};const a=(e.respawn_failures??0)+1;return{failures:a,notBefore:new Date(n+_(a)).toISOString(),exhausted:a>=u}}o(p,"decideRespawnAttempt");function S(e,n,t){const r=new Date(t+c).toISOString();return s(e,{failures:n,notBefore:r}),{failures:n,notBefore:r,exhausted:!1}}o(S,"deferRespawnWhileOffline");function B(e,n){const t=p(e,n);return s(e.node_id,{failures:t.failures,notBefore:t.notBefore}),t}o(B,"recordRespawnPolicy");function m(e){s(e,{failures:0,notBefore:null})}o(m,"clearRespawnPolicy");export{u as MAX_RESPAWN_ATTEMPTS,c as OFFLINE_RESPAWN_RETRY_MS,m as clearRespawnPolicy,p as decideRespawnAttempt,S as deferRespawnWhileOffline,N as isInBackoff,B as recordRespawnPolicy,_ as respawnBackoffMs};

package/dist/daemon/reconcilers/node-lifecycle/terminating.js

@@ -1,12 +1 @@
-import { recordedPidLiveness } from '../../../core/canvas/pid.js';
-import { requestBrokerTeardown } from '../../../core/runtime/host.js';
-/** Request teardown only while a terminal row still has a daemon handle or a
- * provably live recorded process. An indeterminate pid is left for the next
- * tick: uncertainty never authorizes a signal. */
-export function handleTerminatingRow(row, hasFleetHandle) {
-    if (!hasFleetHandle && (row.pi_pid == null || recordedPidLiveness(row.pi_pid, row.pi_pid_identity) !== 'alive')) {
-        return false;
-    }
-    requestBrokerTeardown(row.node_id);
-    return true;
-}
+var n=Object.defineProperty;var r=(e,i)=>n(e,"name",{value:i,configurable:!0});import{recordedPidLiveness as d}from"../../../core/canvas/pid.js";import{requestBrokerTeardown as t}from"../../../core/runtime/host.js";function a(e,i){return!i&&(e.pi_pid==null||d(e.pi_pid,e.pi_pid_identity)!=="alive")?!1:(t(e.node_id),!0)}r(a,"handleTerminatingRow");export{a as handleTerminatingRow};

package/dist/daemon/reconcilers/node-lifecycle/tick.js

@@ -1,146 +1 @@
-// tick.ts — the node-lifecycle tick: one pass over durable rows that decides,
-// for every node, whether it should be executing and what is owed if it is not.
-//
-// Durable row state is the input, and the fleet handle is liveness (design
-// D-1/D-4). The pass is two-phase on purpose: phase one classifies every row and
-// enacts everything that costs no slot, phase two hands the surviving candidates
-// to the freeze lane, which orders them by tier and spends the free slots in
-// that order. Splitting the phases is what makes the tier order mean anything —
-// a single interleaved pass would give slots out in row-creation order.
-import { clearFrozen, endLiveExecution, getNode, } from '../../../core/canvas/index.js';
-import { isSafeNodeId } from '../../../core/canvas/paths.js';
-import { recordedPidLiveness } from '../../../core/canvas/pid.js';
-import { emitEvent } from '../../../core/events/emit.js';
-import { operationIdContext } from '../../../core/events/operation-id.js';
-import { readInterruptedTurn } from '../../../core/canvas/recovery.js';
-import { isProfilePaused } from '../../../core/profiles/manifest.js';
-import { classifyDeadNode } from '../../fleet.js';
-import { applyParkEvent, hasPendingWake, parkEvent } from '../live-obligation.js';
-import { FreezeLaneReconciler } from './freeze-lane.js';
-import { isInBackoff } from './respawn-policy.js';
-import { handleTerminatingRow } from './terminating.js';
-import { wantsExecution } from './wants-execution.js';
-function isTerminal(row) {
-    return row.status === 'done' || row.status === 'canceled' || row.status === 'dead';
-}
-export class NodeLifecycleReconciler {
-    freezeLane = new FreezeLaneReconciler();
-    async run(now, ctx) {
-        const candidates = [];
-        for (const row of ctx.rows) {
-            await operationIdContext.fresh(async () => {
-                try {
-                    await this.classifyRow(now, row, ctx, candidates);
-                }
-                catch (err) {
-                    const id = row.node_id;
-                    emitEvent({
-                        level: 'error',
-                        event: 'node.lifecycle.classify_failed',
-                        ...(isSafeNodeId(id) ? { node_id: id } : { fields: { affected_node_id: id } }),
-                        error: err,
-                    });
-                }
-            });
-        }
-        return this.freezeLane.run(now, { fleet: ctx.fleet, candidates });
-    }
-    async classifyRow(now, row, ctx, candidates) {
-        const id = row.node_id;
-        if (isTerminal(row)) {
-            if (handleTerminatingRow(row, ctx.fleet.has(id)))
-                return;
-            if (row.pi_pid != null && recordedPidLiveness(row.pi_pid, row.pi_pid_identity) === 'dead') {
-                endLiveExecution(id, { reason: 'observed-dead' });
-            }
-            if (row.frozen_at != null)
-                candidates.push({ row, enact: 'thaw' });
-            return;
-        }
-        // 1. A fleet handle IS execution, except profile pause must stop a broker
-        // that registered after pause's fast scan. The fleet records this exact
-        // interruption before SIGTERM so resume cannot classify it as a crash.
-        if (ctx.fleet.has(id)) {
-            if (isProfilePaused(row.profile_id))
-                ctx.fleet.interruptForProfilePause(id);
-            else
-                this.thawMark(row);
-            return;
-        }
-        // A paused profile launches nothing, and its stuck-delivery episode is over
-        // rather than merely stalled — the pause is not a delivery failure.
-        if (isProfilePaused(row.profile_id)) {
-            this.freezeLane.endEpisode(id);
-            return;
-        }
-        // 3. Nothing is owed: drop the freeze mark, and settle a parked row whose
-        //    conversation has nothing left to wake it.
-        if (!wantsExecution(row)) {
-            this.thawMark(row);
-            this.settleParked(row);
-            return;
-        }
-        // 4. Backoff owns this row's next launch; it holds no slot.
-        if (isInBackoff(row, now))
-            return;
-        // An idle row that wants execution is a stuck delivery, and the freeze lane
-        // owns its episode rules.
-        if (row.status === 'idle') {
-            candidates.push({ row, enact: 'idle-release' });
-            return;
-        }
-        // 5. An active row with no recorded pid has no broker to rule on, so the
-        //    dead-row table — which answers "this node's engine died, what now?" —
-        //    has no jurisdiction. Only the freeze mark distinguishes the two ways a
-        //    row gets here: a launcher that reached the ledger and was turned away
-        //    (the mark, and the launch it is still owed), versus a birth still on
-        //    its way to the launch seam, which owns its own launch and must be left
-        //    alone rather than raced or written off as a boot failure.
-        if (row.pi_pid == null) {
-            if (row.respawn_not_before != null) {
-                candidates.push({ row, enact: 'policy' });
-                return;
-            }
-            if (row.frozen_at != null)
-                candidates.push({ row, enact: 'thaw' });
-            return;
-        }
-        // 6. A recorded pid: prove it is not alive before writing it off. An
-        //    indeterminate probe leaves the row for the next tick — the failure
-        //    mode is delay, never a wrong kill.
-        if (recordedPidLiveness(row.pi_pid, row.pi_pid_identity) !== 'dead')
-            return;
-        // A pause interruption needs two passes after resume: the first consumes
-        // its marker without failure or launch, and retaining the PID lets the
-        // second recognize the same dead row for ordinary recovery.
-        if (!ctx.fleet.hasProfilePauseInterruption(id))
-            endLiveExecution(id, { reason: 'observed-dead' });
-        // 7. The invariant-5 policy table, on the same inputs an exit event gives
-        //    it. 8. A verdict that needs no broker is enacted right here, because it
-        //    costs no slot; a respawn becomes a candidate for the freeze lane.
-        const action = classifyDeadNode(getNode(id), readInterruptedTurn(id)?.interrupted === true, hasPendingWake(id));
-        if (action === 'respawn-fresh' || action === 'respawn-cycle' || action === 'respawn-resume') {
-            candidates.push({ row, enact: 'policy' });
-            return;
-        }
-        await ctx.fleet.applyDeadRowPolicy(id);
-        this.thawMark(row);
-    }
-    thawMark(row) {
-        if (row.frozen_at == null)
-            return;
-        clearFrozen(row.node_id);
-    }
-    /** An idle row with no wake-worthy inbox entry still needs the lifecycle
-     *  settlement the live park clock applies: once nothing live remains, this is
-     *  history rather than a permanently protected idle row. The row is already
-     *  parked, so only a terminalizing verdict is worth writing. */
-    settleParked(row) {
-        if (row.status !== 'idle')
-            return;
-        this.freezeLane.endEpisode(row.node_id);
-        const event = parkEvent(row.node_id, row.lifecycle);
-        if (event !== 'release')
-            applyParkEvent(row.node_id, event);
-    }
-}
+var p=Object.defineProperty;var f=(s,i)=>p(s,"name",{value:i,configurable:!0});import{clearFrozen as u,endLiveExecution as d,getNode as c}from"../../../core/canvas/index.js";import{isSafeNodeId as m}from"../../../core/canvas/paths.js";import{recordedPidLiveness as l}from"../../../core/canvas/pid.js";import{emitEvent as h}from"../../../core/events/emit.js";import{operationIdContext as _}from"../../../core/events/operation-id.js";import{readInterruptedTurn as y}from"../../../core/canvas/recovery.js";import{isProfilePaused as o}from"../../../core/profiles/manifest.js";import{classifyDeadNode as P}from"../../fleet.js";import{applyParkEvent as k,hasPendingWake as v,parkEvent as z}from"../live-obligation.js";import{FreezeLaneReconciler as L}from"./freeze-lane.js";import{isInBackoff as E}from"./respawn-policy.js";import{handleTerminatingRow as R}from"./terminating.js";import{wantsExecution as I}from"./wants-execution.js";function M(s){return s.status==="done"||s.status==="canceled"||s.status==="dead"}f(M,"isTerminal");class H{static{f(this,"NodeLifecycleReconciler")}freezeLane=new L;async run(i,e){const n=[];for(const r of e.rows)await _.fresh(async()=>{try{await this.classifyRow(i,r,e,n)}catch(t){const a=r.node_id;h({level:"error",event:"node.lifecycle.classify_failed",...m(a)?{node_id:a}:{fields:{affected_node_id:a}},error:t})}});return this.freezeLane.run(i,{fleet:e.fleet,candidates:n})}async classifyRow(i,e,n,r){const t=e.node_id;if(M(e)){if(R(e,n.fleet.has(t)))return;e.pi_pid!=null&&l(e.pi_pid,e.pi_pid_identity)==="dead"&&d(t,{reason:"observed-dead"}),e.frozen_at!=null&&r.push({row:e,enact:"thaw"});return}if(n.fleet.has(t)){o(e.profile_id)?n.fleet.interruptForProfilePause(t):this.thawMark(e);return}if(o(e.profile_id)){this.freezeLane.endEpisode(t);return}if(!I(e)){this.thawMark(e),this.settleParked(e);return}if(E(e,i))return;if(e.status==="idle"){r.push({row:e,enact:"idle-release"});return}if(e.pi_pid==null){if(e.respawn_not_before!=null){r.push({row:e,enact:"policy"});return}e.frozen_at!=null&&r.push({row:e,enact:"thaw"});return}if(l(e.pi_pid,e.pi_pid_identity)!=="dead")return;n.fleet.hasProfilePauseInterruption(t)||d(t,{reason:"observed-dead"});const a=P(c(t),y(t)?.interrupted===!0,v(t));if(a==="respawn-fresh"||a==="respawn-cycle"||a==="respawn-resume"){r.push({row:e,enact:"policy"});return}await n.fleet.applyDeadRowPolicy(t),this.thawMark(e)}thawMark(i){i.frozen_at!=null&&u(i.node_id)}settleParked(i){if(i.status!=="idle")return;this.freezeLane.endEpisode(i.node_id);const e=z(i.node_id,i.lifecycle);e!=="release"&&k(i.node_id,e)}}export{H as NodeLifecycleReconciler};

package/dist/daemon/reconcilers/node-lifecycle/wants-execution.js

@@ -1,11 +1 @@
-import { hasUnseenWakeMail } from '../../../core/canvas/deliveries.js';
-/** Whether the lifecycle tick must ensure this row has an engine. The durable
- * message handler calls this after appending its entry: that append makes the
- * idle branch's unseen-wake-mail check true for a wake-capable entry. */
-export function wantsExecution(row) {
-    if (row.status === 'active')
-        return true;
-    if (row.status !== 'idle')
-        return false;
-    return hasUnseenWakeMail(row.node_id);
-}
+var i=Object.defineProperty;var e=(t,n)=>i(t,"name",{value:n,configurable:!0});import{hasUnseenWakeMail as a}from"../../../core/canvas/deliveries.js";function u(t){return t.status==="active"?!0:t.status!=="idle"?!1:a(t.node_id)}e(u,"wantsExecution");export{u as wantsExecution};

package/dist/daemon/reconcilers/pending-review-submit.js

@@ -1,36 +1 @@
-// The safety net under a deferred review submit.
-//
-// The companion's turn end is what normally completes a submit the human left
-// waiting (`daemon/api/handlers/broker-ops.ts`). A companion that crashed, was
-// torn down, or ended its turn while this daemon was starting never delivers
-// that settlement, so this pass completes any review whose companion is no
-// longer working. Without it a review could wait forever on a turn end that is
-// never coming.
-import { emitEvent } from '../../core/events/emit.js';
-import { operationIdContext } from '../../core/events/operation-id.js';
-import { listSubmitRequestedRequests } from '../../core/human/requests.js';
-import { completeRequestedSubmit } from '../review/finish.js';
-export class PendingReviewSubmitReconciler {
-    run(now, ctx) {
-        void now; // this pass lists submit-requested reviews unconditionally — nothing here is time-gated; the param is kept for six-way call-site uniformity, matching every other reconciler's run(now, ctx) shape.
-        if (!ctx.lifecycle.acceptsDetachedWork())
-            return;
-        let pending;
-        try {
-            pending = listSubmitRequestedRequests();
-        }
-        catch (error) {
-            operationIdContext.fresh(() => {
-                emitEvent({ level: 'error', event: 'review.deferred_submit.scan_failed', error });
-            });
-            return;
-        }
-        for (const review of pending) {
-            ctx.lifecycle.registerDetached(completeRequestedSubmit(review.request_id, { atCompanionTurnEnd: false }).then(() => { }, (error) => {
-                operationIdContext.fresh(() => {
-                    emitEvent({ level: 'error', event: 'review.deferred_submit.failed', error });
-                });
-            }));
-        }
-    }
-}
+var l=Object.defineProperty;var n=(t,e)=>l(t,"name",{value:e,configurable:!0});import{emitEvent as s}from"../../core/events/emit.js";import{operationIdContext as d}from"../../core/events/operation-id.js";import{listSubmitRequestedRequests as m}from"../../core/human/requests.js";import{completeRequestedSubmit as c}from"../review/finish.js";class b{static{n(this,"PendingReviewSubmitReconciler")}run(e,i){if(!i.lifecycle.acceptsDetachedWork())return;let o;try{o=m()}catch(r){d.fresh(()=>{s({level:"error",event:"review.deferred_submit.scan_failed",error:r})});return}for(const r of o)i.lifecycle.registerDetached(c(r.request_id,{atCompanionTurnEnd:!1}).then(()=>{},f=>{d.fresh(()=>{s({level:"error",event:"review.deferred_submit.failed",error:f})})}))}}export{b as PendingReviewSubmitReconciler};