@north-light/crouter 0.3.318 → 0.3.320

package/dist/daemon/reconcilers/controller-death.js

@@ -1,14 +1 @@
-import { liveControllerWaits } from '../../core/canvas/waits.js';
-import { operationIdContext } from '../../core/events/operation-id.js';
-import { enqueueControllerDeathNotice } from '../../core/feed/messages.js';
-export class ControllerDeathReconciler {
-    run(now, ctx) {
-        void now;
-        void ctx;
-        for (const wait of liveControllerWaits()) {
-            operationIdContext.fresh(() => {
-                enqueueControllerDeathNotice(wait.nodeId, wait.controllerId);
-            });
-        }
-    }
-}
+var l=Object.defineProperty;var t=(r,o)=>l(r,"name",{value:o,configurable:!0});import{liveControllerWaits as n}from"../../core/canvas/waits.js";import{operationIdContext as a}from"../../core/events/operation-id.js";import{enqueueControllerDeathNotice as c}from"../../core/feed/messages.js";class s{static{t(this,"ControllerDeathReconciler")}run(o,i){for(const e of n())a.fresh(()=>{c(e.nodeId,e.controllerId)})}}export{s as ControllerDeathReconciler};

package/dist/daemon/reconcilers/cron-lane.js

@@ -1,29 +1 @@
-import { emitEvent } from '../../core/events/emit.js';
-import { operationIdContext } from '../../core/events/operation-id.js';
-import { recoverStaleCronLeases, runDueCrons } from '../cron-run.js';
-export class CronLaneReconciler {
-    run(now, ctx) {
-        // Recover stale leases before admitting due work. Every settlement remains
-        // detached from the serial tick but is registered for teardown drain.
-        operationIdContext.fresh(() => {
-            try {
-                recoverStaleCronLeases(now, {
-                    register: (settlement) => ctx.lifecycle.registerDetached(settlement),
-                });
-            }
-            catch (err) {
-                emitEvent({ level: 'error', event: 'cron.lease_recovery.failed', error: err });
-            }
-        });
-        if (!ctx.lifecycle.acceptsDetachedWork())
-            return;
-        try {
-            runDueCrons(now, {
-                register: (settlement) => ctx.lifecycle.registerDetached(settlement),
-            });
-        }
-        catch (err) {
-            emitEvent({ level: 'error', event: 'cron.run.failed', error: err });
-        }
-    }
-}
+var l=Object.defineProperty;var t=(c,r)=>l(c,"name",{value:r,configurable:!0});import{emitEvent as i}from"../../core/events/emit.js";import{operationIdContext as n}from"../../core/events/operation-id.js";import{recoverStaleCronLeases as a,runDueCrons as s}from"../cron-run.js";class h{static{t(this,"CronLaneReconciler")}run(r,o){if(n.fresh(()=>{try{a(r,{register:t(e=>o.lifecycle.registerDetached(e),"register")})}catch(e){i({level:"error",event:"cron.lease_recovery.failed",error:e})}}),!!o.lifecycle.acceptsDetachedWork())try{s(r,{register:t(e=>o.lifecycle.registerDetached(e),"register")})}catch(e){i({level:"error",event:"cron.run.failed",error:e})}}}export{h as CronLaneReconciler};

package/dist/daemon/reconcilers/delivery-lane.js

@@ -1,130 +1 @@
-import { randomUUID } from 'node:crypto';
-import { rmSync } from 'node:fs';
-import { claimExternalActionDelivery, dueExternalActionDeliveries, messageBodyForDelivery, settleDelivery } from '../../core/canvas/deliveries.js';
-import { getNode } from '../../core/canvas/canvas.js';
-import { emitEvent } from '../../core/events/emit.js';
-import { operationIdContext } from '../../core/events/operation-id.js';
-import { createPageRequest, getRequest } from '../../core/human/requests.js';
-import { synthesizedPageDocument, writeSynthesizedPage } from '../../core/human/page-synth.js';
-import { preparePage } from '../../core/human/page-authoring.js';
-import { resolvePageComponents } from '../../core/config.js';
-import { spawnChild } from '../../core/runtime/spawn.js';
-import { runDelivery } from '../delivery/run-delivery.js';
-export const deliveryDaemonInstanceId = randomUUID();
-function adapterFor(delivery) {
-    if (delivery.adapter === null || typeof delivery.adapter['adapter'] !== 'string') {
-        throw new Error(`delivery ${delivery.deliveryId} has no adapter`);
-    }
-    return delivery.adapter;
-}
-function failed(delivery, owner, message) {
-    settleDelivery(delivery.deliveryId, delivery.attempts, owner, {
-        state: 'permanent_failed', failure: { kind: 'spawn_error', message },
-    }, Date.now());
-}
-async function deliverSpawn(delivery, owner, adapter) {
-    const existing = getNode(adapter.nodeId);
-    if (existing !== null) {
-        if (existing.frozen_at !== null || existing.pi_session_id !== null || existing.status === 'idle' || existing.status === 'done' || existing.status === 'canceled') {
-            settleDelivery(delivery.deliveryId, delivery.attempts, owner, { state: 'acknowledged' }, Date.now());
-            return;
-        }
-        failed(delivery, owner, existing.status === 'dead'
-            ? `cron spawn ${adapter.nodeId} recorded a failed birth`
-            : `cron spawn ${adapter.nodeId} found an incomplete birth`);
-        return;
-    }
-    try {
-        await spawnChild({
-            nodeId: adapter.nodeId, kind: adapter.kind, cwd: adapter.cwd, prompt: adapter.prompt,
-            ...(adapter.root ? { root: true, rootLifecycle: adapter.rootLifecycle } : { parent: adapter.parent }),
-            readiness: 'launch', profile: adapter.profile, wakeOrigin: adapter.wakeOrigin,
-        });
-        settleDelivery(delivery.deliveryId, delivery.attempts, owner, { state: 'acknowledged' }, Date.now());
-    }
-    catch (error) {
-        failed(delivery, owner, `cron spawn ${adapter.nodeId} failed: ${error instanceof Error ? error.message : String(error)}`);
-        operationIdContext.fresh(() => emitEvent({ level: 'error', event: 'delivery.cron_spawn_failed', node_id: adapter.nodeId, error, fields: { delivery_id: delivery.deliveryId } }));
-    }
-}
-function preparedCronPage(adapter, stdout) {
-    const synthesized = writeSynthesizedPage(synthesizedPageDocument(adapter.title, adapter.summary, stdout, false));
-    try {
-        return preparePage({
-            sourceFile: synthesized.path,
-            source: { sessionName: adapter.sessionName, ...(adapter.profileName === null ? {} : { profileName: adapter.profileName }) },
-            productKinds: resolvePageComponents(),
-            delivery: { placement: 'inline', inbox: true, reply: false },
-        });
-    }
-    finally {
-        rmSync(synthesized.dir, { recursive: true, force: true });
-    }
-}
-function deliverHuman(delivery, owner, adapter, body) {
-    if (getRequest(adapter.requestId) !== null) {
-        settleDelivery(delivery.deliveryId, delivery.attempts, owner, { state: 'acknowledged' }, Date.now());
-        return;
-    }
-    const stdout = typeof body?.['stdout'] === 'string'
-        ? body['stdout']
-        : null;
-    if (stdout === null) {
-        failed(delivery, owner, `cron human ${adapter.requestId} has no frozen stdout`);
-        return;
-    }
-    try {
-        createPageRequest({ request_id: adapter.requestId, prepared: preparedCronPage(adapter, stdout) });
-        settleDelivery(delivery.deliveryId, delivery.attempts, owner, { state: 'acknowledged' }, Date.now());
-    }
-    catch (error) {
-        failed(delivery, owner, `cron human ${adapter.requestId} failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function deliverExternal(delivery, owner) {
-    const adapter = adapterFor(delivery);
-    const body = messageBodyForDelivery(delivery.deliveryId);
-    if (body === null) {
-        failed(delivery, owner, `delivery ${delivery.deliveryId} has no message body`);
-        return;
-    }
-    if (adapter.adapter === 'subprocess') {
-        await runDelivery({ argv: adapter.argv, cwd: adapter.cwd, document: body, attempt: delivery.attempts }, (settlement) => {
-            settleDelivery(delivery.deliveryId, delivery.attempts, owner, settlement, Date.now());
-        });
-        return;
-    }
-    if (adapter.adapter === 'cron_spawn') {
-        await deliverSpawn(delivery, owner, adapter);
-        return;
-    }
-    deliverHuman(delivery, owner, adapter, body);
-}
-/** The one daemon lane for every configured external action. Node-inbox rows are claimed by their destination. */
-export class DeliveryLaneReconciler {
-    run(now, ctx) {
-        if (!ctx.lifecycle.acceptsDetachedWork())
-            return;
-        let due;
-        try {
-            due = dueExternalActionDeliveries(now);
-        }
-        catch (error) {
-            operationIdContext.fresh(() => emitEvent({ level: 'error', event: 'delivery.scan_failed', error }));
-            return;
-        }
-        for (const candidate of due) {
-            try {
-                const claimed = claimExternalActionDelivery(candidate.deliveryId, now, deliveryDaemonInstanceId);
-                if (claimed === null)
-                    continue;
-                ctx.lifecycle.registerDetached(deliverExternal(claimed, deliveryDaemonInstanceId).catch((error) => {
-                    operationIdContext.fresh(() => emitEvent({ level: 'error', event: 'delivery.failed', error, fields: { delivery_id: claimed.deliveryId } }));
-                }));
-            }
-            catch (error) {
-                operationIdContext.fresh(() => emitEvent({ level: 'error', event: 'delivery.claim_failed', error, fields: { delivery_id: candidate.deliveryId } }));
-            }
-        }
-    }
-}
+var m=Object.defineProperty;var s=(e,r)=>m(e,"name",{value:r,configurable:!0});import{randomUUID as p}from"node:crypto";import{rmSync as y}from"node:fs";import{claimExternalActionDelivery as I,dueExternalActionDeliveries as g,messageBodyForDelivery as h,settleDelivery as a}from"../../core/canvas/deliveries.js";import{getNode as v}from"../../core/canvas/canvas.js";import{emitEvent as l}from"../../core/events/emit.js";import{operationIdContext as c}from"../../core/events/operation-id.js";import{createPageRequest as w,getRequest as D}from"../../core/human/requests.js";import{synthesizedPageDocument as _,writeSynthesizedPage as k}from"../../core/human/page-synth.js";import{preparePage as $}from"../../core/human/page-authoring.js";import{resolvePageComponents as q}from"../../core/config.js";import{spawnChild as x}from"../../core/runtime/spawn.js";import{runDelivery as E}from"../delivery/run-delivery.js";const f=p();function N(e){if(e.adapter===null||typeof e.adapter.adapter!="string")throw new Error(`delivery ${e.deliveryId} has no adapter`);return e.adapter}s(N,"adapterFor");function d(e,r,t){a(e.deliveryId,e.attempts,r,{state:"permanent_failed",failure:{kind:"spawn_error",message:t}},Date.now())}s(d,"failed");async function P(e,r,t){const n=v(t.nodeId);if(n!==null){if(n.frozen_at!==null||n.pi_session_id!==null||n.status==="idle"||n.status==="done"||n.status==="canceled"){a(e.deliveryId,e.attempts,r,{state:"acknowledged"},Date.now());return}d(e,r,n.status==="dead"?`cron spawn ${t.nodeId} recorded a failed birth`:`cron spawn ${t.nodeId} found an incomplete birth`);return}try{await x({nodeId:t.nodeId,kind:t.kind,cwd:t.cwd,prompt:t.prompt,...t.root?{root:!0,rootLifecycle:t.rootLifecycle}:{parent:t.parent},readiness:"launch",profile:t.profile,wakeOrigin:t.wakeOrigin}),a(e.deliveryId,e.attempts,r,{state:"acknowledged"},Date.now())}catch(o){d(e,r,`cron spawn ${t.nodeId} failed: ${o instanceof Error?o.message:String(o)}`),c.fresh(()=>l({level:"error",event:"delivery.cron_spawn_failed",node_id:t.nodeId,error:o,fields:{delivery_id:e.deliveryId}}))}}s(P,"deliverSpawn");function b(e,r){const t=k(_(e.title,e.summary,r,!1));try{return $({sourceFile:t.path,source:{sessionName:e.sessionName,...e.profileName===null?{}:{profileName:e.profileName}},productKinds:q(),delivery:{placement:"inline",inbox:!0,reply:!1}})}finally{y(t.dir,{recursive:!0,force:!0})}}s(b,"preparedCronPage");function z(e,r,t,n){if(D(t.requestId)!==null){a(e.deliveryId,e.attempts,r,{state:"acknowledged"},Date.now());return}const o=typeof n?.stdout=="string"?n.stdout:null;if(o===null){d(e,r,`cron human ${t.requestId} has no frozen stdout`);return}try{w({request_id:t.requestId,prepared:b(t,o)}),a(e.deliveryId,e.attempts,r,{state:"acknowledged"},Date.now())}catch(i){d(e,r,`cron human ${t.requestId} failed: ${i instanceof Error?i.message:String(i)}`)}}s(z,"deliverHuman");async function S(e,r){const t=N(e),n=h(e.deliveryId);if(n===null){d(e,r,`delivery ${e.deliveryId} has no message body`);return}if(t.adapter==="subprocess"){await E({argv:t.argv,cwd:t.cwd,document:n,attempt:e.attempts},o=>{a(e.deliveryId,e.attempts,r,o,Date.now())});return}if(t.adapter==="cron_spawn"){await P(e,r,t);return}z(e,r,t,n)}s(S,"deliverExternal");class J{static{s(this,"DeliveryLaneReconciler")}run(r,t){if(!t.lifecycle.acceptsDetachedWork())return;let n;try{n=g(r)}catch(o){c.fresh(()=>l({level:"error",event:"delivery.scan_failed",error:o}));return}for(const o of n)try{const i=I(o.deliveryId,r,f);if(i===null)continue;t.lifecycle.registerDetached(S(i,f).catch(u=>{c.fresh(()=>l({level:"error",event:"delivery.failed",error:u,fields:{delivery_id:i.deliveryId}}))}))}catch(i){c.fresh(()=>l({level:"error",event:"delivery.claim_failed",error:i,fields:{delivery_id:o.deliveryId}}))}}}export{J as DeliveryLaneReconciler,f as deliveryDaemonInstanceId};

package/dist/daemon/reconcilers/live-obligation.js

@@ -1,87 +1 @@
-import { newestReportRef, hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPendingCronWake, subscribersOf, } from '../../core/canvas/index.js';
-import { fullName } from '../../core/canvas/labels.js';
-import { countTickets } from '../../core/canvas/attention.js';
-import { hasUnseenWakeMail } from '../../core/canvas/deliveries.js';
-import { readOutputRequest } from '../../core/runtime/structured-output.js';
-import { focusOf } from '../../core/runtime/placement.js';
-import { hasAttachedBrokerViewers } from '../../core/runtime/broker/client-registry.js';
-import { fanDoctrineWake } from '../../core/runtime/close.js';
-import { readFault } from '../../core/canvas/recovery.js';
-import { transition } from '../../core/runtime/lifecycle.js';
-/** Durable work that requires a node to remain automatically wakeable. */
-export function hasLiveObligation(nodeId) {
-    return hasActiveLiveSubscription(nodeId)
-        || hasLiveMessageWait(nodeId)
-        || hasPendingCronWake(nodeId)
-        || countTickets(nodeId) > 0
-        || readOutputRequest(nodeId).state !== 'absent';
-}
-/** Whether anything would drive a turn if this node's engine came back right
- *  now: durable work that must wake it, mail it has not seen, or a human
- *  already looking at it. The negative is what makes re-launching a dead
- *  node's engine pure cost — it would boot, load its context, sit at an idle
- *  prompt, and wait out the park clock.
- *
- *  Deferred mail deliberately does not count: it rides the node's next natural
- *  cycle rather than causing one. */
-export function hasPendingWake(nodeId) {
-    if (hasLiveObligation(nodeId))
-        return true;
-    if (hasUnseenWakeMail(nodeId))
-        return true;
-    return hasHumanViewer(nodeId);
-}
-/** Whether a person is looking at this node right now: a focused viewer pane,
- *  or a broker client that declared itself attending. A client that hellos with
- *  `attends: false` is a system observer and deliberately does not count, which
- *  is how Northlight Core identifies itself — so an open product page is
- *  invisible here, while crouter's own local and remote viewers are not. */
-export function hasHumanViewer(nodeId) {
-    return focusOf(nodeId) !== null || hasAttachedBrokerViewers(nodeId);
-}
-export function parkEvent(nodeId, lifecycle) {
-    // Attendance defeats unattended parking outright: the grace exists to settle
-    // a conversation nobody is in, and terminalizing a node somebody is watching
-    // is the one outcome the grace must never reach. The live clock resets its
-    // own timer on the same test, so this covers the paths that reach a verdict
-    // without it — the settlement re-check after a parking turn, and the tick's
-    // sweep over already-idle rows. The live clock discards its timer on that
-    // same reset, so parking resumes a full grace after the last viewer detaches.
-    if (hasHumanViewer(nodeId))
-        return 'release';
-    if (hasLiveObligation(nodeId))
-        return 'release';
-    const fault = readFault(nodeId);
-    if (fault?.link === 'pi→provider' && fault.retry.disposition === 'fatal')
-        return 'release';
-    if (lifecycle === 'resident')
-        return hasUnseenWakeMail(nodeId) ? 'release' : 'park';
-    if (hasUnseenWakeMail(nodeId))
-        return 'release';
-    return hasLiveSubscriber(nodeId) ? 'release' : 'cancel';
-}
-/** Apply an unattended decision and notify subscribers of automatic completion.
- *  This is the DEGRADED enactment: no summary turn ran, so subscribers get the
- *  doctrine notice instead of the node's own report. The live clock's good path
- *  (broker settlement after a parking turn) enacts `park` directly and fans
- *  nothing — the node's report is the notice.
- *
- *  The notice is DEFERRED: a node settling quietly at the end of its unattended
- *  grace is not an event worth starting a manager's cycle for, so it rides the
- *  manager's next natural cycle and arrives alongside whatever does.
- *
- *  Only `park` fans, and only a resident parks, so the notice speaks about a
- *  resident throughout: its conversation ended without a final report, its state
- *  lives in whatever report it did leave, and a message reopens it. */
-export function applyParkEvent(nodeId, event) {
-    const node = event === 'cancel'
-        ? transition(nodeId, event, { reason: 'stranded' })
-        : transition(nodeId, event);
-    if (event !== 'park')
-        return;
-    const ref = newestReportRef(nodeId);
-    const pointer = ref === null
-        ? `It left no report behind; \`crtr node inspect show ${nodeId}\` shows where it stands.`
-        : `Its latest report is where it left things: \`crtr canvas history read ${ref}\`.`;
-    fanDoctrineWake(nodeId, subscribersOf(nodeId), `Resident concluded — ${fullName(node)} (${nodeId}) had nothing left to wake it through its unattended grace, so its conversation was concluded. It submitted no final report. ${pointer} A message to it reopens it on a fresh cycle.`, { reason: 'child-auto-done', child: nodeId }, 'deferred');
-}
+var c=Object.defineProperty;var e=(r,t)=>c(r,"name",{value:t,configurable:!0});import{newestReportRef as p,hasActiveLiveSubscription as l,hasLiveMessageWait as h,hasLiveSubscriber as m,hasPendingCronWake as k,subscribersOf as b}from"../../core/canvas/index.js";import{fullName as g}from"../../core/canvas/labels.js";import{countTickets as w}from"../../core/canvas/attention.js";import{hasUnseenWakeMail as s}from"../../core/canvas/deliveries.js";import{readOutputRequest as v}from"../../core/runtime/structured-output.js";import{focusOf as x}from"../../core/runtime/placement.js";import{hasAttachedBrokerViewers as W}from"../../core/runtime/broker/client-registry.js";import{fanDoctrineWake as $}from"../../core/runtime/close.js";import{readFault as y}from"../../core/canvas/recovery.js";import{transition as n}from"../../core/runtime/lifecycle.js";function o(r){return l(r)||h(r)||k(r)||w(r)>0||v(r).state!=="absent"}e(o,"hasLiveObligation");function C(r){return o(r)||s(r)?!0:u(r)}e(C,"hasPendingWake");function u(r){return x(r)!==null||W(r)}e(u,"hasHumanViewer");function D(r,t){if(u(r)||o(r))return"release";const i=y(r);return i?.link==="pi\u2192provider"&&i.retry.disposition==="fatal"?"release":t==="resident"?s(r)?"release":"park":s(r)||m(r)?"release":"cancel"}e(D,"parkEvent");function F(r,t){const i=t==="cancel"?n(r,t,{reason:"stranded"}):n(r,t);if(t!=="park")return;const a=p(r),f=a===null?`It left no report behind; \`crtr node inspect show ${r}\` shows where it stands.`:`Its latest report is where it left things: \`crtr canvas history read ${a}\`.`;$(r,b(r),`Resident concluded \u2014 ${g(i)} (${r}) had nothing left to wake it through its unattended grace, so its conversation was concluded. It submitted no final report. ${f} A message to it reopens it on a fresh cycle.`,{reason:"child-auto-done",child:r},"deferred")}e(F,"applyParkEvent");export{F as applyParkEvent,u as hasHumanViewer,o as hasLiveObligation,C as hasPendingWake,D as parkEvent};

package/dist/daemon/reconcilers/managed-worktree-sweep.js

@@ -1,202 +1 @@
-// The daemon lane that drives managed-worktree reconciliation.
-//
-// It owns WHEN and HOW MANY; `core/worktree-sweep.ts` owns what a single
-// reconciliation does. The lane never blocks the supervision tick: it registers
-// one detached pass and returns immediately, and only one pass is ever in
-// flight, so passes cannot overlap however long a repository takes to answer.
-//
-// NOTHING that spawns a subprocess runs on the tick, and nothing spawns one PER
-// CANDIDATE. `run()` does no work beyond timing; the detached pass reads the
-// canvas, applies the budget, and then takes ONE asynchronous `ps` snapshot
-// that classifies every budgeted candidate's engine. A per-pid probe here would
-// stall the daemon once per stuck worktree.
-//
-// Cost is flat regardless of backlog. The candidate scan touches only terminal
-// nodes, and only those carrying an unreconciled worktree record reach a Git
-// call at all — normally none, so the pass costs zero subprocesses. When there
-// is a backlog, a fixed per-pass budget walks the candidates round-robin, so
-// work per minute is the same whether three worktrees are stuck or three
-// hundred.
-import { getNode, getRow, listNodes } from '../../core/canvas/index.js';
-import { isSafeNodeId } from '../../core/canvas/paths.js';
-import { captureLivenessSnapshotAsync, recordedPidLiveness } from '../../core/canvas/pid.js';
-import { emitEvent } from '../../core/events/emit.js';
-import { operationIdContext } from '../../core/events/operation-id.js';
-import { isDueForSweep, isReconcilable, reconcileManagedWorktree } from '../../core/worktree-sweep.js';
-export const WORKTREE_SWEEP_INTERVAL_MS = 60 * 1000;
-/** Candidates reconciled per pass. Bounds the work a large backlog can demand. */
-export const WORKTREE_SWEEP_BUDGET = 3;
-const TERMINAL_STATUSES = ['done', 'dead', 'canceled'];
-function isTerminal(row) {
-    return TERMINAL_STATUSES.includes(row.status);
-}
-/** A closed record already has an explicit close disposition. An open record
- *  reaches the sweep only when its owner published a final result; a crash or
- *  cancellation leaves its managed checkout available for explicit recovery. */
-function hasSweepDisposition(row, wt) {
-    return wt?.state === 'closed' || (wt?.state === 'open' && row.status === 'done' && row.final_report !== null);
-}
-/** Is this node's engine definitively gone?
- *
- *  Terminal status alone is not enough: `push final` marks a node `done` while
- *  its broker is still running out of the managed checkout, which is exactly
- *  the case that made cleanup deferred in the first place. So the sweep waits
- *  for terminal status AND the absence of any live engine, and an
- *  INDETERMINATE pid probe counts as live — uncertainty must never authorize
- *  deleting a checkout something may still be writing to.
- *
- *  `isClaimed` rather than `has`: a revive that has reserved its slot but not
- *  yet registered its broker is a node coming back to life, and the checkout it
- *  is about to run in must not be removed underneath it. */
-function engineIsGone(row, fleet, snapshot) {
-    if (fleet.isClaimed(row.node_id))
-        return false;
-    if (row.frozen_at !== null)
-        return false;
-    if (!isTerminal(row))
-        return false;
-    if (!hasSweepDisposition(row, getNode(row.node_id)?.managed_worktree))
-        return false;
-    return recordedPidLiveness(row.pi_pid, row.pi_pid_identity, snapshot) === 'dead';
-}
-/** The eligibility recheck the reconciliation runs immediately before EVERY Git
- *  mutation, synchronously and with no subprocess: a revive that won the race
- *  makes this false and the mutation never happens.
- *
- *  It re-reads the row rather than trusting the classification the pass began
- *  with, and it compares the recorded engine identity against the one that was
- *  classified dead — a row whose pid or pid identity moved has been relaunched,
- *  whatever its status column currently says. */
-function eligibilityGuard(row, fleet) {
-    const nodeId = row.node_id;
-    const pid = row.pi_pid;
-    const identity = row.pi_pid_identity;
-    return {
-        stillEligible: () => {
-            if (fleet.isClaimed(nodeId))
-                return false;
-            const current = getRow(nodeId);
-            if (current === null || !isTerminal(current) || current.frozen_at !== null)
-                return false;
-            if (!hasSweepDisposition(current, getNode(nodeId)?.managed_worktree))
-                return false;
-            return current.pi_pid === pid && current.pi_pid_identity === identity;
-        },
-    };
-}
-export class ManagedWorktreeSweepReconciler {
-    lastSweepAt = Number.NEGATIVE_INFINITY;
-    inFlight = false;
-    /** Round-robin cursor over candidate node ids, so a permanently stuck record
-     *  at the head of the list cannot starve the ones behind it. */
-    cursor = 0;
-    run(now, ctx) {
-        if (this.inFlight)
-            return;
-        if (now - this.lastSweepAt < WORKTREE_SWEEP_INTERVAL_MS)
-            return;
-        if (!ctx.lifecycle.acceptsDetachedWork())
-            return;
-        this.lastSweepAt = now;
-        this.inFlight = true;
-        const pass = this.sweep(now, ctx.fleet).finally(() => {
-            this.inFlight = false;
-        });
-        ctx.lifecycle.registerDetached(pass);
-    }
-    /** Terminal nodes whose managed worktree is unreconciled and whose backoff has
-     *  elapsed. Canvas reads only — engine liveness is classified later, for the
-     *  budgeted few, from one shared process snapshot. Returns null when the
-     *  canvas could not be read, which authorizes nothing. */
-    candidates(now) {
-        let rows;
-        try {
-            rows = listNodes({ status: [...TERMINAL_STATUSES] });
-        }
-        catch (err) {
-            operationIdContext.fresh(() => {
-                emitEvent({ level: 'error', event: 'worktree.sweep.scan_failed', error: err });
-            });
-            return null;
-        }
-        const due = [];
-        for (const row of rows) {
-            let wt;
-            try {
-                wt = getNode(row.node_id)?.managed_worktree;
-            }
-            catch {
-                continue; // an unreadable record proves no ownership; leave it alone
-            }
-            if (!isReconcilable(wt) || wt == null)
-                continue;
-            if (!hasSweepDisposition(row, wt))
-                continue;
-            if (!isDueForSweep(wt, now))
-                continue;
-            due.push(row.node_id);
-        }
-        return due;
-    }
-    async sweep(now, fleet) {
-        const candidates = this.candidates(now);
-        if (candidates === null || candidates.length === 0)
-            return;
-        if (this.cursor >= candidates.length)
-            this.cursor = 0;
-        const start = this.cursor;
-        const take = Math.min(WORKTREE_SWEEP_BUDGET, candidates.length);
-        const budgeted = [];
-        for (let i = 0; i < take; i += 1)
-            budgeted.push(candidates[(start + i) % candidates.length]);
-        this.cursor = (start + take) % candidates.length;
-        // One process-table read for the whole pass, off the tick. A null snapshot
-        // is unknown liveness, and unknown never authorizes destroying a checkout,
-        // so the pass simply ends and the next one retries.
-        const snapshot = await captureLivenessSnapshotAsync();
-        if (snapshot === null)
-            return;
-        for (const nodeId of budgeted) {
-            const row = getRow(nodeId);
-            if (row === null || !engineIsGone(row, fleet, snapshot))
-                continue;
-            await this.reconcileOne(row, now, fleet);
-        }
-    }
-    async reconcileOne(row, now, fleet) {
-        const nodeId = row.node_id;
-        const target = isSafeNodeId(nodeId) ? { node_id: nodeId } : {};
-        const affected = isSafeNodeId(nodeId) ? {} : { affected_node_id: nodeId };
-        try {
-            const outcome = await reconcileManagedWorktree(nodeId, eligibilityGuard(row, fleet), now);
-            operationIdContext.fresh(() => {
-                if (outcome.status === 'complete') {
-                    emitEvent({
-                        level: 'info',
-                        event: 'worktree.sweep.reconciled',
-                        outcome: 'succeeded',
-                        ...target,
-                        fields: { ...affected, ...(outcome.stash === undefined ? {} : { base_checkout_stash: outcome.stash }) },
-                    });
-                    return;
-                }
-                if (outcome.status === 'skipped')
-                    return;
-                if (outcome.status === 'refused' && outcome.unchanged === true)
-                    return; // nothing moved; nothing to say
-                emitEvent({
-                    level: outcome.status === 'failed' ? 'error' : 'warn',
-                    event: outcome.status === 'failed' ? 'worktree.sweep.failed' : 'worktree.sweep.refused',
-                    outcome: outcome.status === 'failed' ? 'failed' : 'skipped',
-                    ...target,
-                    fields: { ...affected, reason: outcome.reason, ...(outcome.detail === undefined ? {} : { detail: outcome.detail }) },
-                });
-            });
-        }
-        catch (err) {
-            operationIdContext.fresh(() => {
-                emitEvent({ level: 'error', event: 'worktree.sweep.failed', ...target, error: err, fields: affected });
-            });
-        }
-    }
-}
+var E=Object.defineProperty;var a=(t,e)=>E(t,"name",{value:e,configurable:!0});import{getNode as f,getRow as _,listNodes as k}from"../../core/canvas/index.js";import{isSafeNodeId as m}from"../../core/canvas/paths.js";import{captureLivenessSnapshotAsync as y,recordedPidLiveness as S}from"../../core/canvas/pid.js";import{emitEvent as c}from"../../core/events/emit.js";import{operationIdContext as p}from"../../core/events/operation-id.js";import{isDueForSweep as I,isReconcilable as v,reconcileManagedWorktree as T}from"../../core/worktree-sweep.js";const N=60*1e3,R=3,g=["done","dead","canceled"];function w(t){return g.includes(t.status)}a(w,"isTerminal");function h(t,e){return e?.state==="closed"||e?.state==="open"&&t.status==="done"&&t.final_report!==null}a(h,"hasSweepDisposition");function A(t,e,i){return e.isClaimed(t.node_id)||t.frozen_at!==null||!w(t)||!h(t,f(t.node_id)?.managed_worktree)?!1:S(t.pi_pid,t.pi_pid_identity,i)==="dead"}a(A,"engineIsGone");function W(t,e){const i=t.node_id,s=t.pi_pid,o=t.pi_pid_identity;return{stillEligible:a(()=>{if(e.isClaimed(i))return!1;const n=_(i);return n===null||!w(n)||n.frozen_at!==null||!h(n,f(i)?.managed_worktree)?!1:n.pi_pid===s&&n.pi_pid_identity===o},"stillEligible")}}a(W,"eligibilityGuard");class C{static{a(this,"ManagedWorktreeSweepReconciler")}lastSweepAt=Number.NEGATIVE_INFINITY;inFlight=!1;cursor=0;run(e,i){if(this.inFlight||e-this.lastSweepAt<N||!i.lifecycle.acceptsDetachedWork())return;this.lastSweepAt=e,this.inFlight=!0;const s=this.sweep(e,i.fleet).finally(()=>{this.inFlight=!1});i.lifecycle.registerDetached(s)}candidates(e){let i;try{i=k({status:[...g]})}catch(o){return p.fresh(()=>{c({level:"error",event:"worktree.sweep.scan_failed",error:o})}),null}const s=[];for(const o of i){let n;try{n=f(o.node_id)?.managed_worktree}catch{continue}!v(n)||n==null||h(o,n)&&I(n,e)&&s.push(o.node_id)}return s}async sweep(e,i){const s=this.candidates(e);if(s===null||s.length===0)return;this.cursor>=s.length&&(this.cursor=0);const o=this.cursor,n=Math.min(R,s.length),d=[];for(let l=0;l<n;l+=1)d.push(s[(o+l)%s.length]);this.cursor=(o+n)%s.length;const r=await y();if(r!==null)for(const l of d){const u=_(l);u===null||!A(u,i,r)||await this.reconcileOne(u,e,i)}}async reconcileOne(e,i,s){const o=e.node_id,n=m(o)?{node_id:o}:{},d=m(o)?{}:{affected_node_id:o};try{const r=await T(o,W(e,s),i);p.fresh(()=>{if(r.status==="complete"){c({level:"info",event:"worktree.sweep.reconciled",outcome:"succeeded",...n,fields:{...d,...r.stash===void 0?{}:{base_checkout_stash:r.stash}}});return}r.status!=="skipped"&&(r.status==="refused"&&r.unchanged===!0||c({level:r.status==="failed"?"error":"warn",event:r.status==="failed"?"worktree.sweep.failed":"worktree.sweep.refused",outcome:r.status==="failed"?"failed":"skipped",...n,fields:{...d,reason:r.reason,...r.detail===void 0?{}:{detail:r.detail}}}))})}catch(r){p.fresh(()=>{c({level:"error",event:"worktree.sweep.failed",...n,error:r,fields:d})})}}}export{C as ManagedWorktreeSweepReconciler,R as WORKTREE_SWEEP_BUDGET,N as WORKTREE_SWEEP_INTERVAL_MS};

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

@@ -1,82 +1 @@
-import { dueNodeDeadlines, subscribersOf, } from '../../core/canvas/index.js';
-import { emitEvent } from '../../core/events/emit.js';
-import { isProfilePaused } from '../../core/profiles/manifest.js';
-import { operationIdContext } from '../../core/events/operation-id.js';
-import { errorClassFromFault } from '../../core/fault-classifier.js';
-import { fanDoctrineWake } from '../../core/runtime/close.js';
-import { readFault } from '../../core/canvas/recovery.js';
-import { requestBrokerTeardown } from '../../core/runtime/host.js';
-import { transition } from '../../core/runtime/lifecycle.js';
-/** Enforce absolute spawn deadlines independently of the tick's live-row scan. */
-export class NodeDeadlineReconciler {
-    run(now) {
-        let rows;
-        try {
-            rows = dueNodeDeadlines(new Date(now).toISOString());
-        }
-        catch (error) {
-            emitEvent({ level: 'error', event: 'node_deadline.scan_failed', error });
-            return;
-        }
-        for (const row of rows) {
-            if (isProfilePaused(row.profile_id))
-                continue;
-            operationIdContext.fresh(() => this.expire(row, now));
-        }
-    }
-    expire(row, now) {
-        const deadlineAt = row.deadline_at;
-        if (deadlineAt === null || deadlineAt === undefined)
-            return;
-        const fault = readFault(row.node_id);
-        const lastFatalFault = fault?.retry.disposition === 'fatal' ? fault : null;
-        let terminal;
-        try {
-            terminal = transition(row.node_id, 'cancel', {
-                reason: 'deadline_exceeded',
-                outcome: {
-                    detail: {
-                        schema: 'crtr.node-outcome-detail/v1',
-                        deadline: { deadline_at: deadlineAt, elapsed_ms: now - Date.parse(deadlineAt) },
-                        ...(lastFatalFault === null ? {} : {
-                            message: lastFatalFault.message,
-                            fault_kind: lastFatalFault.kind,
-                            error_class: errorClassFromFault(lastFatalFault).class,
-                        }),
-                    },
-                },
-            });
-        }
-        catch (error) {
-            emitEvent({ level: 'error', event: 'node_deadline.terminalize_failed', node_id: row.node_id, error, fields: { deadline_at: deadlineAt } });
-            return;
-        }
-        // cancel's requireNoFinalReport gate lets a same-instant canonical final win;
-        // only the terminal write that latched this deadline outcome may reap the host.
-        if (terminal.status !== 'canceled' || terminal.outcome_reason !== 'deadline_exceeded')
-            return;
-        try {
-            requestBrokerTeardown(row.node_id);
-        }
-        catch (error) {
-            emitEvent({ level: 'error', event: 'node_deadline.teardown_failed', node_id: row.node_id, error, fields: { deadline_at: deadlineAt } });
-        }
-        try {
-            fanDoctrineWake(row.node_id, subscribersOf(row.node_id), 'child-deadline-exceeded', { reason: 'child-deadline-exceeded', child: row.node_id });
-        }
-        catch (error) {
-            emitEvent({ level: 'error', event: 'node_deadline.notify_failed', node_id: row.node_id, error, fields: { deadline_at: deadlineAt } });
-        }
-        try {
-            emitEvent({
-                level: 'error',
-                event: 'node_deadline.expired',
-                node_id: row.node_id,
-                fields: { deadline_at: deadlineAt, elapsed_ms: now - Date.parse(deadlineAt) },
-            });
-        }
-        catch {
-            // Event emission must not make a committed deadline outcome retry teardown.
-        }
-    }
-}
+var c=Object.defineProperty;var s=(o,e)=>c(o,"name",{value:e,configurable:!0});import{dueNodeDeadlines as _,subscribersOf as f}from"../../core/canvas/index.js";import{emitEvent as n}from"../../core/events/emit.js";import{isProfilePaused as m}from"../../core/profiles/manifest.js";import{operationIdContext as u}from"../../core/events/operation-id.js";import{errorClassFromFault as p}from"../../core/fault-classifier.js";import{fanDoctrineWake as v}from"../../core/runtime/close.js";import{readFault as h}from"../../core/canvas/recovery.js";import{requestBrokerTeardown as x}from"../../core/runtime/host.js";import{transition as y}from"../../core/runtime/lifecycle.js";class S{static{s(this,"NodeDeadlineReconciler")}run(e){let r;try{r=_(new Date(e).toISOString())}catch(d){n({level:"error",event:"node_deadline.scan_failed",error:d});return}for(const d of r)m(d.profile_id)||u.fresh(()=>this.expire(d,e))}expire(e,r){const d=e.deadline_at;if(d==null)return;const l=h(e.node_id),t=l?.retry.disposition==="fatal"?l:null;let a;try{a=y(e.node_id,"cancel",{reason:"deadline_exceeded",outcome:{detail:{schema:"crtr.node-outcome-detail/v1",deadline:{deadline_at:d,elapsed_ms:r-Date.parse(d)},...t===null?{}:{message:t.message,fault_kind:t.kind,error_class:p(t).class}}}})}catch(i){n({level:"error",event:"node_deadline.terminalize_failed",node_id:e.node_id,error:i,fields:{deadline_at:d}});return}if(!(a.status!=="canceled"||a.outcome_reason!=="deadline_exceeded")){try{x(e.node_id)}catch(i){n({level:"error",event:"node_deadline.teardown_failed",node_id:e.node_id,error:i,fields:{deadline_at:d}})}try{v(e.node_id,f(e.node_id),"child-deadline-exceeded",{reason:"child-deadline-exceeded",child:e.node_id})}catch(i){n({level:"error",event:"node_deadline.notify_failed",node_id:e.node_id,error:i,fields:{deadline_at:d}})}try{n({level:"error",event:"node_deadline.expired",node_id:e.node_id,fields:{deadline_at:d,elapsed_ms:r-Date.parse(d)}})}catch{}}}}export{S as NodeDeadlineReconciler};