@north-light/cli 0.0.0 → 0.3.414

package/dist/daemon/reconcilers/fault-retry-backstop.js

@@ -0,0 +1 @@
+var A=Object.defineProperty;var d=(r,t)=>A(r,"name",{value:t,configurable:!0});import{listPendingProviderRetries as g,readLiveTurn as _}from"../../core/canvas/recovery.js";import{probeOnline as I}from"../../core/runtime/connectivity.js";import{nextFaultRetry as y}from"../../core/runtime/fault-recovery.js";import{emitEvent as f}from"../../core/events/emit.js";import{operationIdContext as p}from"../../core/events/operation-id.js";import{isSafeNodeId as b}from"../../core/canvas/paths.js";import{brokerSignalStreams as R}from"../api/handlers/broker-signals.js";const h=2*6e4,v=15e3;function m(r){const{fault:t}=r;if(t.retry.nextAt!==void 0){const i=Date.parse(t.retry.nextAt);return Number.isFinite(i)?i:null}const n=Date.parse(r.updatedAt),s=y(t,n);return Number.isFinite(n)&&s!==null?n+s.delayMs:null}d(m,"dueAtMs");class M{static{d(this,"FaultRetryBackstopReconciler")}deps;lastScanAt=Number.NEGATIVE_INFINITY;scanning=null;nudgedAt=new Map;constructor(t={}){this.deps=t}run(t,n){if(this.scanning!==null)return this.scanning;if(!n.lifecycle.acceptsDetachedWork()||t-this.lastScanAt<v)return Promise.resolve();this.lastScanAt=t;const s=this.scan(t,n).catch(i=>{p.fresh(()=>{f({level:"warn",event:"fault_retry_backstop.scan_failed",error:i})})}).finally(()=>{this.scanning=null});return this.scanning=s,n.lifecycle.registerDetached(s),s}async scan(t,n){const s=(this.deps.list??g)(),i=new Set(s.map(e=>e.fault.faultId));for(const e of this.nudgedAt.keys())i.has(e)||this.nudgedAt.delete(e);const o=this.deps.busy??(e=>_(e)?.busy===!0),u=s.filter(e=>{if(!n.fleet.has(e.nodeId)||o(e.nodeId))return!1;const l=m(e);if(l===null||t<l+h)return!1;const a=this.nudgedAt.get(e.fault.faultId);return a===void 0||t-a>=h});if(u.length===0)return;let c;for(const e of u){if(e.fault.kind==="connection"&&(c??=await(this.deps.probeOnline??(()=>I()))(),!c)||!n.fleet.has(e.nodeId)||o(e.nodeId))continue;this.nudgedAt.set(e.fault.faultId,t);const l=(this.deps.nudge??(a=>R.nudgeFaultRetry(a)))(e.nodeId);p.fresh(()=>{f({level:"info",event:"fault_retry_backstop.nudged",...b(e.nodeId)?{node_id:e.nodeId}:{},fields:{kind:e.fault.kind,since:e.fault.since,delivered:l,overdue_ms:t-(m(e)??t)}})})}}}export{v as FAULT_RETRY_SCAN_INTERVAL_MS,h as FAULT_RETRY_STALE_GRACE_MS,M as FaultRetryBackstopReconciler,m as dueAtMs};

package/dist/daemon/reconcilers/grove-instance-sweep.d.ts

@@ -0,0 +1,36 @@
+import { type NodeRow } from '../../core/canvas/index.js';
+import { type PsLivenessSnapshot } from '../../core/canvas/pid.js';
+import type { FleetRegistry } from '../../core/runtime/fleet.js';
+import type { DetachedWorkLifecycle } from './broker-supervision.js';
+export declare const GROVE_INSTANCE_SWEEP_INTERVAL_MS: number;
+export declare const GROVE_INSTANCE_SWEEP_BUDGET = 3;
+export declare const GROVE_INSTANCE_SWEEP_RETRY_DELAY_MS: number;
+type GroveExecution = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+};
+export interface GroveInstanceSweepOperations {
+    resolveBinary(): string | null;
+    listTerminalNodes(): NodeRow[];
+    getNodeRow(nodeId: string): NodeRow | null;
+    execute(binary: string, args: readonly string[]): Promise<GroveExecution>;
+    captureLiveness(): Promise<PsLivenessSnapshot | null>;
+}
+export interface GroveInstanceSweepContext {
+    lifecycle: DetachedWorkLifecycle;
+    fleet: FleetRegistry;
+}
+export declare class GroveInstanceSweepReconciler {
+    private readonly operations;
+    private lastSweepAt;
+    private inFlight;
+    private cursor;
+    private readonly retryAfter;
+    constructor(operations?: GroveInstanceSweepOperations);
+    run(now: number, ctx: GroveInstanceSweepContext): void;
+    private sweep;
+}
+export {};

package/dist/daemon/reconcilers/grove-instance-sweep.js

@@ -0,0 +1 @@
+var A=Object.defineProperty;var l=(e,t)=>A(e,"name",{value:t,configurable:!0});import{spawn as S}from"node:child_process";import{statSync as I}from"node:fs";import{delimiter as T,join as j}from"node:path";import{getRow as G,listNodes as R}from"../../core/canvas/index.js";import{isSafeNodeId as w}from"../../core/canvas/paths.js";import{captureLivenessSnapshotAsync as b,recordedPidLiveness as x}from"../../core/canvas/pid.js";import{emitEvent as p}from"../../core/events/emit.js";import{operationIdContext as h}from"../../core/events/operation-id.js";import{isParked as C}from"../../core/runtime/lifecycle.js";const F=60*1e3,P=3,L=300*1e3,E=["done","dead","canceled"];function _(e){return E.includes(e.status)&&!C(e)}l(_,"isClosed");function M(){const e=process.env.PATH;if(e===void 0)return null;for(const t of e.split(T)){const i=j(t===""?process.cwd():t,"grove");try{const r=I(i);if(r.isFile()&&(r.mode&73)!==0)return i}catch{}}return null}l(M,"resolveGroveBinary");function O(e,t){return new Promise(i=>{let r;try{r=S(e,[...t],{stdio:["ignore","pipe","pipe"]})}catch(n){i({code:null,signal:null,stdout:"",stderr:"",error:n instanceof Error?n:new Error(String(n))});return}let a="",s="",c=!1;const u=l(n=>{c||(c=!0,i(n))},"settle");r.stdout.on("data",n=>{a+=n.toString()}),r.stderr.on("data",n=>{s+=n.toString()}),r.on("error",n=>u({code:null,signal:null,stdout:a,stderr:s,error:n})),r.on("close",(n,f)=>u({code:n,signal:f,stdout:a,stderr:s}))})}l(O,"executeGrove");const V={resolveBinary:M,listTerminalNodes:l(()=>R({status:[...E]}),"listTerminalNodes"),getNodeRow:G,execute:O,captureLiveness:b};function B(e){let t;try{t=JSON.parse(e)}catch{return null}if(typeof t!="object"||t===null||!Array.isArray(t.projects))return null;const i=[];for(const r of t.projects){if(typeof r!="object"||r===null)continue;const a=r.name,s=r.instances;if(!(typeof a!="string"||!Array.isArray(s)))for(const c of s){if(typeof c!="object"||c===null)continue;const u=c.name,n=c.slot,f=c.spec?.labels,m=typeof f=="object"&&f!==null?f.owner:void 0;typeof u=="string"&&typeof n=="number"&&typeof m=="string"&&i.push({project:a,name:u,slot:n,owner:m})}}return i}l(B,"instancesFromInventory");function k(e,t,i){return _(e)&&!t.isClaimed(e.node_id)&&e.frozen_at===null&&x(e.pi_pid,e.pi_pid_identity,i)==="dead"}l(k,"engineIsGone");function D(e,t,i){if(t.isClaimed(e.node_id))return!1;const r=i(e.node_id);return r!==null&&_(r)&&r.frozen_at===null&&r.pi_pid===e.pi_pid&&r.pi_pid_identity===e.pi_pid_identity}l(D,"stillEligible");function N(e){if(e.error!==void 0)return e.error;const t=e.stderr.trim()||e.stdout.trim()||`Grove exited with ${e.signal??e.code??"an unknown status"}`;return new Error(t)}l(N,"executionError");function g(e){return`${e.project}/${e.name}`}l(g,"instanceKey");class X{static{l(this,"GroveInstanceSweepReconciler")}operations;lastSweepAt=Number.NEGATIVE_INFINITY;inFlight=!1;cursor=0;retryAfter=new Map;constructor(t=V){this.operations=t}run(t,i){if(this.inFlight||t-this.lastSweepAt<F||!i.lifecycle.acceptsDetachedWork())return;this.lastSweepAt=t,this.inFlight=!0;const r=Promise.resolve().then(()=>this.sweep(t,i.fleet)).finally(()=>{this.inFlight=!1});i.lifecycle.registerDetached(r)}async sweep(t,i){const r=this.operations.resolveBinary();if(r===null)return;let a;try{a=this.operations.listTerminalNodes().filter(_)}catch(o){h.fresh(()=>{p({level:"error",event:"grove.sweep.scan_failed",error:o})});return}if(a.length===0)return;const s=await this.operations.execute(r,["list","--json"]);if(s.error!==void 0||s.code!==0||s.signal!==null){h.fresh(()=>{p({level:"error",event:"grove.sweep.list_failed",error:N(s)})});return}const c=B(s.stdout);if(c===null){h.fresh(()=>{p({level:"error",event:"grove.sweep.list_failed",error:new Error("grove list --json returned invalid inventory JSON")})});return}const u=new Map(a.map(o=>[o.node_id,o])),n=c.filter(o=>u.get(o.owner)!==void 0&&(this.retryAfter.get(g(o))??Number.NEGATIVE_INFINITY)<=t).sort((o,d)=>o.project.localeCompare(d.project)||o.slot-d.slot||o.name.localeCompare(d.name));if(n.length===0)return;this.cursor>=n.length&&(this.cursor=0);const f=Math.min(P,n.length),m=Array.from({length:f},(o,d)=>n[(this.cursor+d)%n.length]);this.cursor=(this.cursor+f)%n.length;const v=await this.operations.captureLiveness();if(v!==null)for(const o of m){const d=u.get(o.owner);if(!k(d,i,v)||!D(d,i,this.operations.getNodeRow))continue;const y=await this.operations.execute(r,["uproot",g(o),"--force"]);if(y.error===void 0&&y.code===0&&y.signal===null){this.retryAfter.delete(g(o)),h.fresh(()=>{p({level:"info",event:"grove.sweep.reconciled",outcome:"succeeded",...w(o.owner)?{node_id:o.owner}:{fields:{affected_node_id:o.owner}}})});continue}this.retryAfter.set(g(o),t+L),h.fresh(()=>{p({level:"error",event:"grove.sweep.failed",outcome:"failed",...w(o.owner)?{node_id:o.owner}:{fields:{affected_node_id:o.owner}},error:N(y)})})}}}export{P as GROVE_INSTANCE_SWEEP_BUDGET,F as GROVE_INSTANCE_SWEEP_INTERVAL_MS,L as GROVE_INSTANCE_SWEEP_RETRY_DELAY_MS,X as GroveInstanceSweepReconciler};

package/dist/daemon/reconcilers/live-obligation.d.ts

@@ -0,0 +1,65 @@
+import { type Lifecycle } from '../../core/canvas/index.js';
+import { type LifecycleEvent } from '../../core/runtime/lifecycle.js';
+import type { FleetRegistry } from '../../core/runtime/fleet.js';
+/** Durable work that requires a node to remain automatically wakeable. */
+export declare function hasLiveObligation(nodeId: string): boolean;
+/** 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 declare function hasPendingWake(nodeId: string): boolean;
+/** The retention sweep's hold: a node with a launch claim, durable work that
+ *  must wake it, or a person looking at it is never pruned, whatever its age.
+ *  Unseen mail is deliberately not a hold: it never wakes a terminal node, and
+ *  children keep writing a finished manager's inbox, so it would retain most
+ *  finished history forever. The stale sweep checks unseen mail itself. */
+export declare function retentionHold(fleet: Pick<FleetRegistry, 'isClaimed'>): (nodeId: string) => boolean;
+/** 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 crouter cloud identifies itself — so an open product page is
+ *  invisible here, while crouter's own local and remote viewers are not. */
+export declare function hasHumanViewer(nodeId: string): boolean;
+/** What parking an unattended node actually amounts to — the one rule both the
+ *  live-broker park clock and the lifecycle tick apply.
+ *
+ *  `release` — something can still wake it, a person is watching it, or a
+ *              fatal provider fault prevents its engine from completing the
+ *              summary turn; parking is a pause.
+ *  `park`    — a resident with nothing left to wake it has completed its
+ *              conversation, and the row becomes prunable history. The live
+ *              clock asks it for a summary turn first; this verdict is what
+ *              that turn's settlement re-evaluates before enacting.
+ *  `cancel`  — a terminal node that never pushed a final was torn down before
+ *              finishing, which is what `canceled` records; it stays revivable
+ *              and becomes prunable. A live subscriber still awaiting its
+ *              report is an outstanding deliverable, so such a node keeps its
+ *              wakeable idle row instead of being written off.
+ *
+ *  Undelivered mail holds the row, with one carve-out: a deferred-only unseen
+ *  set does not hold a RESIDENT. Deferred mail never wakes a node on its own,
+ *  and parking a resident is reversible — a message sent to it revives it and
+ *  flushes the held mail on that cycle. A terminalized row takes no such
+ *  cycle, so unread mail of any tier keeps it from being written off: the
+ *  invariant is that content a sender already handed over is never dropped.
+ */
+export type ParkEvent = Extract<LifecycleEvent, 'release' | 'park' | 'cancel'>;
+export declare function parkEvent(nodeId: string, lifecycle: Lifecycle): ParkEvent;
+/** 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 declare function applyParkEvent(nodeId: string, event: ParkEvent): void;

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

@@ -0,0 +1 @@
+var f=Object.defineProperty;var e=(r,t)=>f(r,"name",{value:t,configurable:!0});import{hasActiveLiveSubscription as l,hasLiveMessageWait as p,hasLiveSubscriber as m,hasPendingCronWake as h}from"../../core/canvas/index.js";import{fullName as k}from"../../core/canvas/labels.js";import{newestReportName as g}from"../../core/feed/reports.js";import{countTickets as w}from"../../core/canvas/attention.js";import{hasUnseenWakeMail as s}from"../../core/canvas/deliveries.js";import{readOutputRequest as b}from"../../core/runtime/structured-output.js";import{focusOf as v}from"../../core/runtime/placement.js";import{hasAttachedBrokerViewers as x}from"../api/viewer-presence.js";import{publishNotice as $}from"../../core/runtime/close.js";import{readFault as L}from"../../core/canvas/recovery.js";import{transition as u}from"../../core/runtime/lifecycle.js";function a(r){return l(r)||p(r)||h(r)||w(r)>0||b(r).state!=="absent"}e(a,"hasLiveObligation");function V(r){return a(r)||s(r)?!0:n(r)}e(V,"hasPendingWake");function q(r){return t=>r.isClaimed(t)||a(t)||n(t)}e(q,"retentionHold");function n(r){return v(r)!==null||x(r)}e(n,"hasHumanViewer");function B(r,t){if(n(r)||a(r))return"release";const i=L(r);return i?.link==="pi\u2192provider"&&i.retry.disposition==="fatal"?"release":t==="resident"?s(r)?"release":"park":s(r)||m(r)?"release":"cancel"}e(B,"parkEvent");function F(r,t){const i=t==="cancel"?u(r,t,{reason:"stranded"}):u(r,t);if(t!=="park")return;const o=g(r),c=o===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 read ${o}\`.`;$(r,"notice.close",`Resident concluded \u2014 ${k(i)} (${r}) had nothing left to wake it through its unattended grace, so its conversation was concluded. It submitted no final report. ${c} A message to it reopens it on a fresh cycle.`,{reason:"child-auto-done",child:r},"deferred")}e(F,"applyParkEvent");export{F as applyParkEvent,n as hasHumanViewer,a as hasLiveObligation,V as hasPendingWake,B as parkEvent,q as retentionHold};

package/dist/daemon/reconcilers/managed-worktree-sweep.d.ts

@@ -0,0 +1,24 @@
+import type { FleetRegistry } from '../../core/runtime/fleet.js';
+import type { DetachedWorkLifecycle } from './broker-supervision.js';
+export declare const WORKTREE_SWEEP_INTERVAL_MS: number;
+/** Candidates reconciled per pass. Bounds the work a large backlog can demand. */
+export declare const WORKTREE_SWEEP_BUDGET = 3;
+export interface ManagedWorktreeSweepContext {
+    lifecycle: DetachedWorkLifecycle;
+    fleet: FleetRegistry;
+}
+export declare class ManagedWorktreeSweepReconciler {
+    private lastSweepAt;
+    private inFlight;
+    /** Round-robin cursor over candidate node ids, so a permanently stuck record
+     *  at the head of the list cannot starve the ones behind it. */
+    private cursor;
+    run(now: number, ctx: ManagedWorktreeSweepContext): void;
+    /** 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. */
+    private candidates;
+    private sweep;
+    private reconcileOne;
+}

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

@@ -0,0 +1 @@
+var E=Object.defineProperty;var o=(t,e)=>E(t,"name",{value:e,configurable:!0});import{getNode as p,getRow as h}from"../../core/canvas/index.js";import{managedWorktreeSweepCandidates as k}from"../../core/canvas/managed-worktree-sweep-candidates.js";import{isSafeNodeId as _}from"../../core/canvas/paths.js";import{captureLivenessSnapshotAsync as S,recordedPidLiveness as y}from"../../core/canvas/pid.js";import{emitEvent as c}from"../../core/events/emit.js";import{operationIdContext as u}from"../../core/events/operation-id.js";import{reconcileManagedWorktree as w}from"../../core/worktree-sweep.js";const I=60*1e3,v=3,T=["done","dead","canceled"];function m(t){return T.includes(t.status)}o(m,"isTerminal");function g(t,e){return e?.state==="closed"||e?.state==="open"&&t.status==="done"&&t.final_report!==null}o(g,"hasSweepDisposition");function A(t,e,i){return e.isClaimed(t.node_id)||t.frozen_at!==null||!m(t)||!g(t,p(t.node_id)?.managed_worktree)?!1:y(t.pi_pid,t.pi_pid_identity,i)==="dead"}o(A,"engineIsGone");function N(t,e){const i=t.node_id,n=t.pi_pid,a=t.pi_pid_identity;return{stillEligible:o(()=>{if(e.isClaimed(i))return!1;const s=h(i);return s===null||!m(s)||s.frozen_at!==null||!g(s,p(i)?.managed_worktree)?!1:s.pi_pid===n&&s.pi_pid_identity===a},"stillEligible")}}o(N,"eligibilityGuard");class L{static{o(this,"ManagedWorktreeSweepReconciler")}lastSweepAt=Number.NEGATIVE_INFINITY;inFlight=!1;cursor=0;run(e,i){if(this.inFlight||e-this.lastSweepAt<I||!i.lifecycle.acceptsDetachedWork())return;this.lastSweepAt=e,this.inFlight=!0;const n=this.sweep(e,i.fleet).finally(()=>{this.inFlight=!1});i.lifecycle.registerDetached(n)}candidates(e){try{return k(e)}catch(i){return u.fresh(()=>{c({level:"error",event:"worktree.sweep.scan_failed",error:i})}),null}}async sweep(e,i){const n=this.candidates(e);if(n===null||n.length===0)return;this.cursor>=n.length&&(this.cursor=0);const a=this.cursor,s=Math.min(v,n.length),d=[];for(let l=0;l<s;l+=1)d.push(n[(a+l)%n.length]);this.cursor=(a+s)%n.length;const r=await S();if(r!==null)for(const l of d){const f=h(l);f===null||!A(f,i,r)||await this.reconcileOne(f,e,i)}}async reconcileOne(e,i,n){const a=e.node_id,s=_(a)?{node_id:a}:{},d=_(a)?{}:{affected_node_id:a};try{const r=await w(a,N(e,n),i);u.fresh(()=>{if(r.status==="complete"){c({level:"info",event:"worktree.sweep.reconciled",outcome:"succeeded",...s,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",...s,fields:{...d,reason:r.reason,...r.detail===void 0?{}:{detail:r.detail}}}))})}catch(r){u.fresh(()=>{c({level:"error",event:"worktree.sweep.failed",...s,error:r,fields:d})})}}}export{L as ManagedWorktreeSweepReconciler,v as WORKTREE_SWEEP_BUDGET,I as WORKTREE_SWEEP_INTERVAL_MS};

package/dist/daemon/reconcilers/node-deadline.d.ts

@@ -0,0 +1,7 @@
+/** Enforce absolute spawn deadlines independently of the tick's live-row scan. */
+export declare class NodeDeadlineReconciler {
+    run(now: number): void;
+}
+/** The one deadline terminalization path. Structured-request expiry reuses it
+ * even when a profile is paused, because its dedicated broker must not resume. */
+export declare function expireNodeDeadline(nodeId: string, deadlineAt: string, now: number): Promise<void>;

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

@@ -0,0 +1 @@
+var m=Object.defineProperty;var s=(r,t)=>m(r,"name",{value:t,configurable:!0});import{dueNodeDeadlines as _,getNode as u}from"../../core/canvas/index.js";import{emitEvent as i}from"../../core/events/emit.js";import{isProfilePaused as p}from"../../core/profiles/manifest.js";import{operationIdContext as w}from"../../core/events/operation-id.js";import{errorClassFromFault as h}from"../../core/fault-classifier.js";import{publishNotice as v}from"../../core/runtime/close.js";import{readFault as x}from"../../core/canvas/recovery.js";import{requestBrokerTeardown as f}from"../../core/runtime/host.js";import{transition as y}from"../../core/runtime/lifecycle.js";class z{static{s(this,"NodeDeadlineReconciler")}run(t){let a;try{a=_(new Date(t).toISOString())}catch(e){i({level:"error",event:"node_deadline.scan_failed",error:e});return}for(const e of a)p(e.profile_id)||e.deadline_at===null||e.deadline_at===void 0||w.fresh(()=>{D(e.node_id,e.deadline_at,t).catch(d=>{i({level:"error",event:"node_deadline.expire_failed",node_id:e.node_id,error:d,fields:{deadline_at:e.deadline_at}})})})}}async function D(r,t,a){const e=u(r);if(e===null||e.status==="done")return;if(e.status==="canceled"||e.status==="dead"){const o=await f(r);if(!o.confirmed)throw o.error??new Error("broker teardown was not confirmed");return}const d=x(r),n=d?.retry.disposition==="fatal"?d:null;let l;try{l=y(r,"cancel",{reason:"deadline_exceeded",outcome:{detail:{schema:"crtr.node-outcome-detail/v1",deadline:{deadline_at:t,elapsed_ms:a-Date.parse(t)},...n===null?{}:{message:n.message,fault_kind:n.kind,error_class:h(n).class}}}})}catch(o){throw i({level:"error",event:"node_deadline.terminalize_failed",node_id:r,error:o,fields:{deadline_at:t}}),o}if(l.status!=="canceled"||l.outcome_reason!=="deadline_exceeded")return;const c=await f(r);if(!c.confirmed)throw c.error??new Error("broker teardown was not confirmed");try{v(r,"notice.deadline","child-deadline-exceeded",{reason:"child-deadline-exceeded",child:r})}catch(o){i({level:"error",event:"node_deadline.notify_failed",node_id:r,error:o,fields:{deadline_at:t}})}try{i({level:"error",event:"node_deadline.expired",node_id:r,fields:{deadline_at:t,elapsed_ms:a-Date.parse(t)}})}catch{}}s(D,"expireNodeDeadline");export{z as NodeDeadlineReconciler,D as expireNodeDeadline};

package/dist/daemon/reconcilers/node-lifecycle/freeze-lane.d.ts

@@ -0,0 +1,48 @@
+import { type NodeRow } from '../../../core/canvas/index.js';
+import type { FleetRegistry } from '../../../core/runtime/fleet.js';
+/** How a candidate spends a slot when its turn comes. `thaw` simply launches a
+ *  row the cap turned away — its disposition was decided when it froze, and the
+ *  dead-row table has no jurisdiction over a broker that never existed.
+ *  `policy` re-enacts the dead-row policy table (which relaunches through
+ *  `reviveNode`); `idle-release` runs the stuck-delivery episode rules before
+ *  relaunching. */
+export type ThawEnactment = 'thaw' | 'policy' | 'idle-release';
+export interface ThawCandidate {
+    row: NodeRow;
+    enact: ThawEnactment;
+}
+/** Tier 1 is a row with nothing waiting for it that simply stopped executing —
+ *  the stalled set, served first. Tier 2 is a row waiting on mail, plus a row
+ *  that held a slot last time and settled nothing with it. */
+export type ThawTier = 1 | 2;
+export interface ThawEntry extends ThawCandidate {
+    tier: ThawTier;
+}
+export interface FreezeLaneContext {
+    fleet: FleetRegistry;
+    candidates: readonly ThawCandidate[];
+}
+/** What stayed frozen this tick, split the way the saturation warning reports
+ *  it. Rows in backoff never reach this lane and are excluded by construction. */
+export interface FrozenCounts {
+    stalled: number;
+    waitingOnMail: number;
+}
+/** 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 declare function thawTier(row: NodeRow, pendingWake: boolean): ThawTier;
+/** 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 declare function compareThaw(a: ThawEntry, b: ThawEntry): number;
+export declare class FreezeLaneReconciler {
+    private readonly relaunchState;
+    /** 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: string): void;
+    run(now: number, ctx: FreezeLaneContext): Promise<FrozenCounts>;
+    private enact;
+    private enactThaw;
+    private enactIdleRelease;
+}

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

@@ -0,0 +1 @@
+var w=Object.defineProperty;var s=(i,t)=>w(i,"name",{value:t,configurable:!0});import{clearFrozen as v,getNode as E,getRow as y}from"../../../core/canvas/index.js";import{fullName as g}from"../../../core/canvas/labels.js";import{isSafeNodeId as d}from"../../../core/canvas/paths.js";import{emitEvent as l}from"../../../core/events/emit.js";import{operationIdContext as A}from"../../../core/events/operation-id.js";import{acknowledgedNodeMailCount as k}from"../../../core/canvas/deliveries.js";import{publishNotice as z}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";import{readInterruptedTurn as S}from"../../../core/canvas/recovery.js";const u=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}s(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)}s(C,"compareThaw");class B{static{s(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 A.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 l({level:"error",event:"node.lifecycle.enact_failed",...d(n)?{node_id:n}:{},error:a,fields:{...d(n)?{}:{affected_node_id:n},enact:r.enact}}),"skipped"}}async enactThaw(t){if(t.lifecycle==="resident"&&E(t.node_id)?.pi_session_id!=null&&!_(t.node_id))return p(t.node_id,"release"),v(t.node_id),"skipped";const r=S(t.node_id)?.interrupted===!0;return(await m(t.node_id,{resume:!0,capacity:"freeze",recovery:!0,...r?{wakeReason:"runtime-restart-abort"}:{}})).outcome==="frozen"?"frozen":"launched"}async enactIdleRelease(t,r){const e=r.node_id,n=k(e),a=this.relaunchState.get(e),c=a===void 0||a.acknowledgedCount!==n,o=c?0:a.attempts;if(o>=u)return this.relaunchState.delete(e),l({level:"warn",event:"broker.idle_release.exhausted",...d(e)?{node_id:e}:{},fields:{...d(e)?{}:{affected_node_id:e},attempts:o,max_attempts:u}}),p(e,"crash",{reason:"launch_failed",outcome:{detail:{schema:"crtr.node-outcome-detail/v1",respawn_failures:o}}}),z(e,"notice.crash",`Child crashed \u2014 ${g(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 f=c?void 0:a?.lastAttempt,h=Math.min(L*2**o,R);return f!==void 0&&t-f<h?"skipped":(await m(e,{resume:!0,capacity:"freeze"})).outcome==="frozen"?"frozen":(this.relaunchState.set(e,{acknowledgedCount:n,attempts:o+1,lastAttempt:t}),l({level:"info",event:"broker.revive.idle_release",...d(e)?{node_id:e}:{},attempt:o+1,fields:{...d(e)?{}:{affected_node_id:e},attempts:o+1,max_attempts:u}}),"launched")}}export{B as FreezeLaneReconciler,C as compareThaw,M as thawTier};

package/dist/daemon/reconcilers/node-lifecycle/respawn-policy.d.ts

@@ -0,0 +1,30 @@
+import { type NodeRow } from '../../../core/canvas/index.js';
+export declare const MAX_RESPAWN_ATTEMPTS = 6;
+/** 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 declare const OFFLINE_RESPAWN_RETRY_MS = 30000;
+export declare function respawnBackoffMs(consecutiveFailures: number): number;
+export interface RespawnAttempt {
+    failures: number;
+    notBefore: string | null;
+    exhausted: boolean;
+}
+/** Whether a durable backoff still holds this row back from a relaunch. */
+export declare function isInBackoff(row: NodeRow, now: number): boolean;
+/** The only respawn-failure policy: progress since launch clears the sequence;
+ * every other missing-engine observation advances it and records its backoff. */
+export declare function decideRespawnAttempt(row: Pick<NodeRow, 'last_settled_at' | 'launched_at' | 'respawn_failures'>, now: number): RespawnAttempt;
+/** 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 declare function deferRespawnWhileOffline(nodeId: string, failures: number, now: number): RespawnAttempt;
+/** Persist the policy decision through the daemon-only canvas writer. */
+export declare function recordRespawnPolicy(row: NodeRow, now: number): RespawnAttempt;
+export declare function clearRespawnPolicy(nodeId: string): void;

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

@@ -0,0 +1 @@
+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.d.ts

@@ -0,0 +1,5 @@
+import type { NodeRow } from '../../../core/canvas/index.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 declare function handleTerminatingRow(row: NodeRow, hasFleetHandle: boolean): boolean;

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

@@ -0,0 +1 @@
+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.d.ts

@@ -0,0 +1,20 @@
+import { type NodeRow } from '../../../core/canvas/index.js';
+import type { FleetRegistry } from '../../../core/runtime/fleet.js';
+import { type FrozenCounts } from './freeze-lane.js';
+export interface NodeLifecycleContext {
+    /** Every active and idle row (human rows excluded), plus terminal rows with
+     *  a recorded pid or frozen mark. */
+    rows: readonly NodeRow[];
+    fleet: FleetRegistry;
+}
+export declare class NodeLifecycleReconciler {
+    private readonly freezeLane;
+    run(now: number, ctx: NodeLifecycleContext): Promise<FrozenCounts>;
+    private classifyRow;
+    private thawMark;
+    /** 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. */
+    private settleParked;
+}

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

@@ -0,0 +1 @@
+var u=Object.defineProperty;var d=(a,i)=>u(a,"name",{value:i,configurable:!0});import{clearFrozen as c,endLiveExecution as l,getNode as m}from"../../../core/canvas/index.js";import{isSafeNodeId as h}from"../../../core/canvas/paths.js";import{recordedPidLiveness as o}from"../../../core/canvas/pid.js";import{emitEvent as _}from"../../../core/events/emit.js";import{operationIdContext as y}from"../../../core/events/operation-id.js";import{readInterruptedTurn as P}from"../../../core/canvas/recovery.js";import{isProfilePaused as p}from"../../../core/profiles/manifest.js";import{isRecoveryHeld as k}from"../../../core/runtime/recovery-hold.js";import{hasUnseenWakeMail as v}from"../../../core/canvas/deliveries.js";import{hasIdleReleaseIntent as z}from"../../../core/runtime/lifecycle.js";import{classifyDeadNode as I}from"../../fleet.js";import{applyParkEvent as L,hasPendingWake as R,parkEvent as E}from"../live-obligation.js";import{FreezeLaneReconciler as M}from"./freeze-lane.js";import{isInBackoff as N}from"./respawn-policy.js";import{handleTerminatingRow as b}from"./terminating.js";import{wantsExecution as g}from"./wants-execution.js";function D(a){return a.status==="done"||a.status==="canceled"||a.status==="dead"}d(D,"isTerminal");class X{static{d(this,"NodeLifecycleReconciler")}freezeLane=new M;async run(i,e){const r=[];for(const n of e.rows)await y.fresh(async()=>{try{await this.classifyRow(i,n,e,r)}catch(t){const s=n.node_id;_({level:"error",event:"node.lifecycle.classify_failed",...h(s)?{node_id:s}:{fields:{affected_node_id:s}},error:t})}});return this.freezeLane.run(i,{fleet:e.fleet,candidates:r})}async classifyRow(i,e,r,n){const t=e.node_id;if(D(e)){if(b(e,r.fleet.has(t)))return;e.pi_pid!=null&&o(e.pi_pid,e.pi_pid_identity)==="dead"&&l(t,{reason:"observed-dead"}),e.frozen_at!=null&&n.push({row:e,enact:"thaw"});return}if(r.fleet.has(t)){p(e.profile_id)?r.fleet.interruptForProfilePause(t):this.thawMark(e);return}if(p(e.profile_id)){this.freezeLane.endEpisode(t);return}if(k(t))return;const s=e.pi_pid!=null&&o(e.pi_pid,e.pi_pid_identity)==="dead";if(s&&!r.fleet.hasProfilePauseInterruption(t)&&l(t,{reason:"observed-dead"}),!g(e)){this.thawMark(e),this.settleParked(e);return}if(N(e,i))return;if(e.status==="idle"&&z(e)&&v(t)){n.push({row:e,enact:"idle-release"});return}if(e.pi_pid==null){if(e.respawn_not_before!=null){n.push({row:e,enact:"policy"});return}e.frozen_at!=null&&n.push({row:e,enact:"thaw"});return}if(!s)return;const f=I(m(t),P(t)?.interrupted===!0,R(t));if(f==="respawn-fresh"||f==="respawn-cycle"||f==="respawn-resume"){n.push({row:e,enact:"policy"});return}await r.fleet.applyDeadRowPolicy(t),this.thawMark(e)}thawMark(i){i.frozen_at!=null&&c(i.node_id)}settleParked(i){if(i.status!=="idle")return;this.freezeLane.endEpisode(i.node_id);const e=E(i.node_id,i.lifecycle);e!=="release"&&L(i.node_id,e)}}export{X as NodeLifecycleReconciler};

package/dist/daemon/reconcilers/node-lifecycle/wants-execution.d.ts

@@ -0,0 +1,8 @@
+import type { NodeRow } from '../../../core/canvas/index.js';
+/** Whether the lifecycle tick must ensure this row has an engine. An idle row
+ * is dormant only after the lifecycle table committed an idle-release; an idle
+ * row without that intent still reaches dead-row recovery. The durable message
+ * handler calls this after appending its entry. */
+export declare function wantsExecution(row: Pick<NodeRow, 'node_id' | 'status'> & {
+    intent?: NodeRow['intent'];
+}): boolean;

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

@@ -0,0 +1 @@
+var a=Object.defineProperty;var t=(e,n)=>a(e,"name",{value:n,configurable:!0});import{hasUnseenWakeMail as i}from"../../../core/canvas/deliveries.js";import{hasIdleReleaseIntent as s}from"../../../core/runtime/lifecycle.js";function l(e){return e.status==="active"?!0:e.status!=="idle"?!1:!s(e)||i(e.node_id)}t(l,"wantsExecution");export{l as wantsExecution};

package/dist/daemon/reconcilers/pending-review-submit.d.ts

@@ -0,0 +1,7 @@
+import type { DetachedWorkLifecycle } from './broker-supervision.js';
+export interface PendingReviewSubmitContext {
+    lifecycle: DetachedWorkLifecycle;
+}
+export declare class PendingReviewSubmitReconciler {
+    run(now: number, ctx: PendingReviewSubmitContext): void;
+}

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

@@ -0,0 +1 @@
+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};

package/dist/daemon/reconcilers/storage-due-work.d.ts

@@ -0,0 +1,32 @@
+import { type StorageClient, type StorageConfig } from '../../core/storage/client.js';
+import type { DetachedWorkLifecycle } from './broker-supervision.js';
+export declare const STORAGE_DUE_WORK_INTERVAL_MS = 60000;
+/** An upload no run has used this long after creation is released. */
+export declare const UNUSED_UPLOAD_TTL_MS: number;
+/** Storage deletes attempted per kind per pass; the rest wait for the next pass. */
+export declare const STORAGE_DUE_WORK_BUDGET = 200;
+/** Consecutive `storage_unavailable` failures after which a pass stops early. */
+export declare const STORAGE_DOWN_AFTER = 3;
+export interface StorageDueWorkContext {
+    lifecycle: DetachedWorkLifecycle;
+}
+export interface StorageDueWorkDeps {
+    config: () => StorageConfig | null;
+    client: () => StorageClient;
+}
+export interface StorageDueWorkResult {
+    marked_uploads: number;
+    expired_shares: number;
+    deleted_uploads: number;
+    deleted_share_objects: number;
+    failed: number;
+}
+export declare class StorageDueWorkReconciler {
+    private readonly deps;
+    private lastPassAt;
+    private inFlight;
+    constructor(deps?: StorageDueWorkDeps);
+    run(now: number, ctx: StorageDueWorkContext): void;
+    /** One pass over the due-work rows. Exposed for tests. */
+    pass(now: number): Promise<StorageDueWorkResult>;
+}

package/dist/daemon/reconcilers/storage-due-work.js

@@ -0,0 +1 @@
+var v=Object.defineProperty;var d=(l,t)=>v(l,"name",{value:t,configurable:!0});import{withCanvasWrite as E}from"../../core/canvas/db.js";import{emitEvent as c}from"../../core/events/emit.js";import{operationIdContext as p}from"../../core/events/operation-id.js";import{RunError as S}from"../../core/runs/operations.js";import{storageClient as k,storageConfig as O}from"../../core/storage/client.js";import{deleteUploadRow as U,expireShares as w,markShareObjectDeleted as R,markUploadsDeletePending as b,pendingUploadDeletes as A,sharesOwingObjectDelete as T,staleUnusedUploads as x}from"../../core/storage/tables.js";const I=6e4,y=1440*6e4,D=200,N=3,F=d(l=>l instanceof S&&l.code==="storage_unavailable","unavailable");class M{static{d(this,"StorageDueWorkReconciler")}deps;lastPassAt=Number.NEGATIVE_INFINITY;inFlight=!1;constructor(t={config:O,client:k}){this.deps=t}run(t,o){if(this.inFlight||t-this.lastPassAt<I||!o.lifecycle.acceptsDetachedWork())return;this.lastPassAt=t;let i;try{i=this.deps.config()}catch(e){p.fresh(()=>c({level:"error",event:"storage.due_work.failed",error:e}));return}if(!i)return;this.inFlight=!0;const f=p.fresh(()=>this.pass(t)).then(()=>{}).catch(e=>{p.fresh(()=>c({level:"error",event:"storage.due_work.failed",error:e}))}).finally(()=>{this.inFlight=!1});o.lifecycle.registerDetached(f)}async pass(t){const o=new Date(t).toISOString(),{marked:i,expired:f}=E(s=>{const a=x(new Date(t-y).toISOString(),s);return b(a,s,o),{marked:a.length,expired:w(o,s).length}}),e={marked_uploads:i,expired_shares:f,deleted_uploads:0,deleted_share_objects:0,failed:0},h=A().slice(0,D),_=T().slice(0,D);if(h.length||_.length){const s=this.deps.client();let a,n=0,u=!1;const g=d(async r=>{if(u)return!1;try{return await r(),n=0,!0}catch(m){return e.failed++,a??=m,n=F(m)?n+1:0,n>=N&&(u=!0),!1}},"attempt");for(const r of h)await g(()=>s.deleteUpload(r.upload_id))&&(U(r.upload_id),e.deleted_uploads++);for(const r of _)await g(()=>s.deleteShare(r.share_id))&&(R(r.share_id),e.deleted_share_objects++);a!==void 0&&c({level:"warn",event:"storage.due_work.deletes_failed",error:a,fields:{failed:e.failed,storage_unavailable:u}})}return(e.marked_uploads||e.expired_shares||e.deleted_uploads||e.deleted_share_objects)&&c({level:"info",event:"storage.due_work.settled",outcome:"succeeded",fields:{...e}}),e}}export{N as STORAGE_DOWN_AFTER,D as STORAGE_DUE_WORK_BUDGET,I as STORAGE_DUE_WORK_INTERVAL_MS,M as StorageDueWorkReconciler,y as UNUSED_UPLOAD_TTL_MS};

package/dist/daemon/reconcilers/storage-maintenance.d.ts

@@ -0,0 +1,69 @@
+import type { FleetRegistry } from '../../core/runtime/fleet.js';
+import type { DetachedWorkLifecycle } from './broker-supervision.js';
+export declare const DEAD_REAP_GRACE_MS: number;
+export declare const RETENTION_SWEEP_INTERVAL_MS: number;
+export declare const RETENTION_TTL_DAYS = 14;
+export declare const CONTEXT_STRIP_GRACE_MS: number;
+/** A separate daemon-owned SQLite connection checkpoints without holding the API's
+ * event loop. A busy reader or another writer is not a reason to block service. */
+export declare function checkpointCanvasWal(path: string): Promise<boolean>;
+export interface StorageMaintenanceContext {
+    /** Carries the managed-worktree sweep's detached Git work off this tick. */
+    lifecycle: DetachedWorkLifecycle;
+    /** A live engine handle is the sweep's proof that a node is NOT disposable. */
+    fleet: FleetRegistry;
+}
+/** Recurring storage cleanup. The in-memory throttle clocks intentionally reset
+ * on daemon boot, so the first tick runs every full sweep — which is also how
+ * managed-worktree reconciliation gets its start-up pass. */
+export declare class StorageMaintenanceReconciler {
+    private lastSpareSweepAt;
+    private lastCreateRequestSweepAt;
+    private lastRunExpiryAt;
+    private lastRunEventPassAt;
+    private runEventCursor;
+    private lastWalCheckpointAt;
+    private walCheckpointInFlight;
+    private lastAnalyzeAt;
+    private lastRetentionSweepAt;
+    private lastContextStripAt;
+    private contextStripInFlight;
+    private focusGcInFlight;
+    /** Wall time of the last cache pass; null until the first one, which runs at daemon boot. */
+    private lastCachePassAt;
+    private cachePassInFlight;
+    private readonly worktreeSweep;
+    private readonly groveInstanceSweep;
+    run(now: number, ctx: StorageMaintenanceContext): void;
+    /** Ask the launcher for one purge of every app's cache folder: at boot, then at most hourly. It is off the due lanes (a sleeping runtime is never woken for it) and skipped where no launcher exists. */
+    private scheduleCachePass;
+    private scheduleWalCheckpoint;
+    /** Milliseconds since the node's last activity ({@link lastActivityMs}). */
+    private msSinceTerminalActivity;
+    /** Delete terminal nodes quiet for {@link RETENTION_TTL_DAYS}, at most once per
+     * {@link RETENTION_SWEEP_INTERVAL_MS}. Rows are deleted on the tick; their
+     * directories are removed as detached work so a large sweep never blocks it. */
+    private sweepRetention;
+    /** Register one detached context-strip pass, at most once per
+     * {@link RETENTION_SWEEP_INTERVAL_MS} and never overlapping another. */
+    private scheduleContextStrip;
+    /** Replace bulky context-folder content of finished nodes quiet for
+     * {@link CONTEXT_STRIP_GRACE_MS} with tombstones. A node is stripped again
+     * only after new activity. App runs are skipped: their files belong to the
+     * app's user. */
+    private stripFinishedContexts;
+    /** Reap only physical placement residue of terminal nodes. The durable row,
+     * graph, and on-disk state remain available for a later manual revive. */
+    private reapDeadResidue;
+    /** Register one detached focus-GC pass, never overlapping another. The pane
+     * probe is a subprocess, and running it on the tick blocks the API socket for
+     * its full duration on every beat. */
+    private scheduleFocusGc;
+    /** Delete focus rows whose recorded tmux pane no longer exists. A failed tmux
+     * probe is "can't tell" and never authorizes deleting every viewport. */
+    private gcStaleFocuses;
+    /** Delete create idempotency keys once their bounded recovery window ends. */
+    private gcCreateRequests;
+    /** Collect dead or expired hidden warm-pool spares. */
+    private gcWarmPool;
+}

package/dist/daemon/reconcilers/storage-maintenance.js

@@ -0,0 +1,8 @@
+var I=Object.defineProperty;var u=(f,t)=>I(f,"name",{value:t,configurable:!0});import{rm as E,stat as A}from"node:fs/promises";import{Worker as S}from"node:worker_threads";import{closeFocusRow as N,getFocusById as y,listFocuses as g,listNodes as R}from"../../core/canvas/index.js";import{pruneExpiredIdempotencyKeys as T}from"../../core/runs/operations.js";import{getNode as C,lastActivityMs as h,listTerminalPlacementResidue as w,pruneExpiredCreateRequests as F,pruneNodes as P}from"../../core/canvas/canvas.js";import{lastContextStripMs as D,stripContextDir as k}from"../../core/canvas/context-strip.js";import{isAppRun as x}from"../../core/canvas/app-run.js";import{isSafeNodeId as c}from"../../core/canvas/paths.js";import{emitEvent as n}from"../../core/events/emit.js";import{operationIdContext as a}from"../../core/events/operation-id.js";import{listLivePanesAsync as b,tearDownNode as W}from"../../core/runtime/placement.js";import{reapStaleSpares as G}from"../../core/runtime/warm-pool.js";import{GroveInstanceSweepReconciler as M}from"./grove-instance-sweep.js";import{ManagedWorktreeSweepReconciler as V}from"./managed-worktree-sweep.js";import{compactRunEvents as L,expireRunEvents as Y}from"../../core/runs/events.js";import{openDb as q}from"../../core/canvas/db.js";import{canvasDbPath as O}from"../../core/canvas/paths.js";import{retentionHold as _}from"./live-obligation.js";import{pruneMemoryReads as z}from"../../core/canvas/memory-reads.js";import{existsSync as H}from"node:fs";import{launcherRequest as K}from"../../launcher/client.js";import{LAUNCHER_SOCKET as U}from"../../launcher/spec.js";import{cachePassDue as $}from"../../launcher/limits/policy.js";const B=10*6e4,Q=60*1e3,X=60*1e3,m=5*6e4,Z=14,j=1440*6e4,J=2e3,ee=5*6e4,te=16*1024*1024;async function re(f){return await A(`${f}-wal`).then(r=>r.size).catch(r=>{if(r.code==="ENOENT")return 0;throw r})<te?!1:new Promise((r,e)=>{const i=new S(`import { DatabaseSync } from 'node:sqlite';
+      import { parentPort, workerData } from 'node:worker_threads';
+      const db = new DatabaseSync(workerData);
+      try {
+        db.exec('PRAGMA busy_timeout = 250');
+        const rows = db.prepare('PRAGMA wal_checkpoint(TRUNCATE)').all();
+        parentPort.postMessage(rows[0]?.busy === 0);
+      } finally { db.close(); }`,{eval:!0,workerData:f});let o=!1;const l=u(d=>{o||(o=!0,clearTimeout(s),r(d))},"finish"),s=setTimeout(()=>{i.terminate(),l(!1)},3e3);i.once("message",l),i.once("error",d=>{o||(o=!0,clearTimeout(s),e(d))}),i.once("exit",()=>l(!1))})}u(re,"checkpointCanvasWal");class Ce{static{u(this,"StorageMaintenanceReconciler")}lastSpareSweepAt=Number.NEGATIVE_INFINITY;lastCreateRequestSweepAt=Number.NEGATIVE_INFINITY;lastRunExpiryAt=Number.NEGATIVE_INFINITY;lastRunEventPassAt=Number.NEGATIVE_INFINITY;runEventCursor=0;lastWalCheckpointAt=Number.NEGATIVE_INFINITY;walCheckpointInFlight=!1;lastAnalyzeAt=Number.NEGATIVE_INFINITY;lastRetentionSweepAt=Number.NEGATIVE_INFINITY;lastContextStripAt=Number.NEGATIVE_INFINITY;contextStripInFlight=!1;focusGcInFlight=!1;lastCachePassAt=null;cachePassInFlight=!1;worktreeSweep=new V;groveInstanceSweep=new M;run(t,r){if(this.reapDeadResidue(t),this.scheduleFocusGc(r),this.gcWarmPool(t),this.gcCreateRequests(t),t-this.lastRunEventPassAt>=J){this.lastRunEventPassAt=t;try{Y(t);const e=L(t,this.runEventCursor);this.runEventCursor=e.cursor}catch(e){console.warn(`run event maintenance failed: ${String(e)}`)}}if(t-this.lastRunExpiryAt>=60*6e4){try{z(t)}catch(e){console.warn(`memory-read log prune failed: ${String(e)}`)}this.lastRunExpiryAt=t}t-this.lastAnalyzeAt>=1440*6e4&&(q().exec("ANALYZE"),this.lastAnalyzeAt=t),this.sweepRetention(t,r),this.scheduleCachePass(t,r),this.scheduleContextStrip(t,r),this.scheduleWalCheckpoint(t,r),this.worktreeSweep.run(t,r),this.groveInstanceSweep.run(t,r)}scheduleCachePass(t,r){this.cachePassInFlight||!$(this.lastCachePassAt,t)||process.platform!=="linux"||!H(U)||r.lifecycle.acceptsDetachedWork()&&(this.lastCachePassAt=t,this.cachePassInFlight=!0,r.lifecycle.registerDetached(K({operation:"cache.purge"}).then(()=>{}).catch(e=>{a.fresh(()=>{n({level:"warn",event:"app.cache.pass_failed",error:e})})}).then(()=>{this.cachePassInFlight=!1})))}scheduleWalCheckpoint(t,r){this.walCheckpointInFlight||t-this.lastWalCheckpointAt<ee||r.lifecycle.acceptsDetachedWork()&&(this.lastWalCheckpointAt=t,this.walCheckpointInFlight=!0,r.lifecycle.registerDetached(re(O()).catch(e=>{console.warn(`canvas WAL checkpoint failed: ${String(e)}`)}).then(()=>{this.walCheckpointInFlight=!1})))}msSinceTerminalActivity(t,r){const e=h(t);return e===0?Number.POSITIVE_INFINITY:r-e}sweepRetention(t,r){t-this.lastRetentionSweepAt<m||r.lifecycle.acceptsDetachedWork()&&(this.lastRetentionSweepAt=t,a.fresh(()=>{try{const e=P({ttlDays:Z,held:_(r.fleet),removeDirs:u(i=>{r.lifecycle.registerDetached(Promise.all(i.map(o=>E(o,{recursive:!0,force:!0}))).then(()=>{}).catch(o=>{a.fresh(()=>{n({level:"error",event:"canvas.retention.failed",error:o})})}))},"removeDirs")});e.pruned.length>0&&n({level:"info",event:"canvas.retention.pruned",outcome:"succeeded",fields:{pruned_count:e.pruned.length}})}catch(e){n({level:"error",event:"canvas.retention.failed",error:e})}}))}scheduleContextStrip(t,r){if(this.contextStripInFlight||t-this.lastContextStripAt<m||!r.lifecycle.acceptsDetachedWork())return;this.lastContextStripAt=t,this.contextStripInFlight=!0;const e=this.stripFinishedContexts(t,r).finally(()=>{this.contextStripInFlight=!1});r.lifecycle.registerDetached(e)}async stripFinishedContexts(t,r){const e=_(r.fleet),i=u(s=>s!==null&&["done","canceled","dead"].includes(s.status)&&(s.pi_pid??null)===null&&(s.frozen_at??null)===null&&!x(s)&&h(s)<t-j&&!e(s.node_id),"eligible");let o=0,l=0;try{for(const s of R({status:["done","canceled","dead"]})){if(!c(s.node_id)||!i(s))continue;const d=await D(s.node_id);if(d!==null&&d>=h(s)||!i(C(s.node_id)))continue;let p;try{p=await k(s.node_id)}catch(v){a.fresh(()=>{n({level:"warn",event:"canvas.context_strip.node_failed",error:v,fields:{node_id:s.node_id}})});continue}p.removed.length>0&&(o+=1,l+=p.bytes)}}catch(s){a.fresh(()=>{n({level:"error",event:"canvas.context_strip.failed",error:s})})}o>0&&a.fresh(()=>{n({level:"info",event:"canvas.context_strip.completed",outcome:"succeeded",fields:{node_count:o,bytes:l}})})}reapDeadResidue(t){let r;try{r=w()}catch(e){a.fresh(()=>{n({level:"error",event:"residue.reap_scan.failed",error:e})});return}for(const e of r){try{if(this.msSinceTerminalActivity(e,t)<B)continue}catch(i){a.fresh(()=>{n({level:"error",event:"residue.reap.failed",...c(e.node_id)?{node_id:e.node_id}:{},error:i,fields:{...c(e.node_id)?{}:{affected_node_id:e.node_id},pane:e.pane,window:e.window,tmux_session:e.tmux_session}})});continue}a.fresh(()=>{try{n({level:"info",event:"residue.reaped",...c(e.node_id)?{node_id:e.node_id}:{},fields:{...c(e.node_id)?{}:{affected_node_id:e.node_id},pane:e.pane,window:e.window,tmux_session:e.tmux_session}}),W(e.node_id)}catch(i){n({level:"error",event:"residue.reap.failed",...c(e.node_id)?{node_id:e.node_id}:{},error:i,fields:{...c(e.node_id)?{}:{affected_node_id:e.node_id},pane:e.pane,window:e.window,tmux_session:e.tmux_session}})}})}}scheduleFocusGc(t){if(this.focusGcInFlight||!t.lifecycle.acceptsDetachedWork())return;this.focusGcInFlight=!0;const r=this.gcStaleFocuses().finally(()=>{this.focusGcInFlight=!1});t.lifecycle.registerDetached(r)}async gcStaleFocuses(){let t;try{t=g()}catch(e){a.fresh(()=>{n({level:"error",event:"focus.gc.failed",error:e})});return}if(t.length===0)return;let r;try{r=await b()}catch(e){a.fresh(()=>{n({level:"error",event:"focus.gc.failed",error:e})});return}if(r!==null)for(const e of t){if(e.pane===null||r.has(e.pane))continue;if(!a.fresh(()=>{try{return y(e.focus_id)?.pane!==e.pane||(n({level:"info",event:"focus.gc.removed",...c(e.node_id)?{node_id:e.node_id}:{},fields:{focus_id:e.focus_id,focus_node_id:e.node_id,pane:e.pane}}),N(e.focus_id)),!0}catch(o){return n({level:"error",event:"focus.gc.failed",error:o}),!1}}))return}}gcCreateRequests(t){t-this.lastCreateRequestSweepAt<X||(this.lastCreateRequestSweepAt=t,a.fresh(()=>{const r=F(t),e=T(t);e>0&&n({level:"info",event:"canvas.idempotency_keys.reaped",outcome:"succeeded",fields:{reaped_count:e}}),r>0&&n({level:"info",event:"canvas.create_requests.reaped",outcome:"succeeded",fields:{reaped_count:r}})}))}gcWarmPool(t){t-this.lastSpareSweepAt<Q||(this.lastSpareSweepAt=t,a.fresh(()=>{const r=G();r.length>0&&n({level:"info",event:"warm_pool.spares_reaped",outcome:"succeeded",fields:{reaped_count:r.length}})}))}}export{j as CONTEXT_STRIP_GRACE_MS,B as DEAD_REAP_GRACE_MS,m as RETENTION_SWEEP_INTERVAL_MS,Z as RETENTION_TTL_DAYS,Ce as StorageMaintenanceReconciler,re as checkpointCanvasWal};

package/dist/daemon/reconcilers/structured-request-lane.d.ts

@@ -0,0 +1,4 @@
+/** Settles rows whose waiter disappeared and retries every incomplete durable effect. */
+export declare class StructuredRequestReconciler {
+    run(now: number): void;
+}

package/dist/daemon/reconcilers/structured-request-lane.js

@@ -0,0 +1 @@
+var u=Object.defineProperty;var c=(o,t)=>u(o,"name",{value:t,configurable:!0});import{withCanvasWrite as n}from"../../core/canvas/db.js";import{incompleteStructuredRequestEffects as d,pendingStructuredRequestsPast as f,settleStructuredRequestIn as l}from"../../core/canvas/structured-requests.js";import{emitEvent as m}from"../../core/events/emit.js";import{applySettlementEffects as s}from"../structured-requests/effects.js";class S{static{c(this,"StructuredRequestReconciler")}run(t){try{for(const e of f(t)){const r=n(i=>l(i,e.request_id,{intended:"expired",now:t}));r.changed&&r.row!==null&&s(r.row)}for(const e of d())s(e)}catch(e){m({level:"error",event:"structured_request.reconcile_failed",error:e})}}}export{S as StructuredRequestReconciler};

package/dist/daemon/resume-detector.d.ts

@@ -0,0 +1,12 @@
+export declare const RESUME_JUMP_MS = 2000;
+export interface ClockSample {
+    wallMs: number;
+    monotonicMs: number;
+}
+export declare function sampleClocks(): ClockSample;
+/** True when the wall clock advanced more than `thresholdMs` beyond the monotonic clock between two samples. */
+export declare function detectResume(previous: ClockSample, current: ClockSample, thresholdMs?: number): boolean;
+/** A detector holding its previous sample; `check()` returns true once per detected resume. */
+export declare function createResumeDetector(sample?: () => ClockSample, thresholdMs?: number): {
+    check(): boolean;
+};

package/dist/daemon/resume-detector.js

@@ -0,0 +1 @@
+var s=Object.defineProperty;var n=(e,t)=>s(e,"name",{value:t,configurable:!0});const l=2e3;function M(){return{wallMs:Date.now(),monotonicMs:Number(process.hrtime.bigint()/1000000n)}}n(M,"sampleClocks");function u(e,t,o=2e3){return t.wallMs-e.wallMs-(t.monotonicMs-e.monotonicMs)>o}n(u,"detectResume");function m(e=M,t=2e3){let o=e();return{check(){const r=e(),c=u(o,r,t);return o=r,c}}}n(m,"createResumeDetector");export{l as RESUME_JUMP_MS,m as createResumeDetector,u as detectResume,M as sampleClocks};

package/dist/daemon/review/comment-notify.d.ts

@@ -0,0 +1,27 @@
+import type { ReviewComment, ReviewRecord } from '../../core/review/types.js';
+export type DeliverMode = 'wake' | 'quiet';
+type CommentVerb = 'create' | 'edit' | 'resolve' | 'reopen' | 'delete';
+export interface CommentDelivery {
+    attempted: boolean;
+    target_node_id?: string;
+    status: 'delivered' | 'skipped' | 'failed';
+    via?: 'engine' | 'inbox';
+    woke: boolean;
+    reason?: 'capacity_frozen';
+    error?: string;
+}
+/** Render the one bounded, durable comment notice delivered to a review companion. */
+export declare function renderCommentNotice(review: ReviewRecord, comment: ReviewComment, verb: CommentVerb): string;
+/**
+ * Best-effort post-commit notice for one review-comment mutation. Delivery and
+ * its audit are deliberately outside the comment's state transaction.
+ */
+export declare function notifyComment(args: {
+    review: ReviewRecord;
+    comment: ReviewComment;
+    verb: CommentVerb;
+    actor_node_id: string | null;
+    deliver: DeliverMode | undefined;
+    operation_id: string;
+}): Promise<CommentDelivery>;
+export {};

package/dist/daemon/review/comment-notify.js

@@ -0,0 +1,2 @@
+var v=Object.defineProperty;var t=(e,n)=>v(e,"name",{value:n,configurable:!0});import{appendDeliveryEvent as c}from"../../core/review/comments.js";import{deliverNodeMessage as l}from"../messaging/node-message.js";function m(e){switch(e){case"create":case"edit":case"reopen":return"wake";case"resolve":case"delete":return"quiet"}}t(m,"defaultDeliverMode");function _(e){return e.anchor.end_line>e.anchor.line?`L${e.anchor.line}-${e.anchor.end_line}`:`L${e.anchor.line}`}t(_,"range");function s(e){const n=e.anchor.quote;return n===void 0||n===""?e.anchor_line_text:n}t(s,"quotedSource");function f(e){switch(e){case"create":return"created";case"edit":return"edited";case"resolve":return"resolved";case"reopen":return"reopened";case"delete":return"deleted"}}t(f,"verbPastTense");function w(e,n,r){return[`Review comment ${n.comment_id} was ${f(r)} in review ${e.review_id}.`,"",`File: ${e.file}`,`Range: ${_(n)}`,"Quoted source:",s(n),"","Comment:",n.text].join(`
+`)}t(w,"renderCommentNotice");function p(e){return e instanceof Error?e.message:String(e)}t(p,"errorMessage");async function $(e){if(e.actor_node_id===e.review.companion_node_id&&e.deliver===void 0)return{attempted:!1,status:"skipped",woke:!1};const n=e.review.companion_node_id,r=e.deliver??m(e.verb),a=w(e.review,e.comment,e.verb);let i;try{i=await l({node_id:n,body:a,label:"review comment",from:"crtrd",mode:r==="wake"?"interactive":"quiet",data:{review_id:e.review.review_id,comment_id:e.comment.comment_id,verb:e.verb},runtime:{kind:"review-comment",facts:{}}})}catch(u){const d={attempted:!0,target_node_id:n,status:"failed",woke:!1,error:p(u)};return c({review_id:e.review.review_id,comment_id:e.comment.comment_id,kind:"notify_failed",payload:d,operation_id:e.operation_id}),d}const o={attempted:!0,target_node_id:n,status:"delivered",via:i.via,woke:i.revived,...i.reason===void 0?{}:{reason:i.reason}};return c({review_id:e.review.review_id,comment_id:e.comment.comment_id,kind:"notified",payload:o,operation_id:e.operation_id}),o}t($,"notifyComment");export{$ as notifyComment,w as renderCommentNotice};

package/dist/daemon/review/companion.d.ts

@@ -0,0 +1,8 @@
+/** Is the companion inside a turn right now? */
+export declare function companionMidTurn(nodeId: string): boolean;
+/** Does the companion hold work it has not yet consumed? A deferred entry is
+ *  excluded for the same reason the settlement policy excludes it: it never
+ *  starts a turn of its own. */
+export declare function companionHasQueuedWork(nodeId: string): boolean;
+/** Would submitting right now step on the companion's work? */
+export declare function companionStillWorking(nodeId: string): boolean;

package/dist/daemon/review/companion.js

@@ -0,0 +1 @@
+var e=Object.defineProperty;var r=(n,o)=>e(n,"name",{value:o,configurable:!0});import{readLiveTurn as i}from"../../core/canvas/recovery.js";import{hasUnseenWakeMail as t}from"../../core/canvas/deliveries.js";function u(n){return i(n)?.busy??!1}r(u,"companionMidTurn");function a(n){return t(n)}r(a,"companionHasQueuedWork");function f(n){return u(n)||a(n)}r(f,"companionStillWorking");export{a as companionHasQueuedWork,u as companionMidTurn,f as companionStillWorking};

package/dist/daemon/review/deliver.d.ts

@@ -0,0 +1,5 @@
+import type { ReviewRecord } from '../../core/review/types.js';
+/** Render the immutable approval fact as plain prose. It is delivered as an
+ *  inbox entry, so the inbox card is its envelope — a nested `<runtime>` card
+ *  here would reach the model escaped and the attached view as raw markup. */
+export declare function renderApprovalMessage(review: ReviewRecord, resultPath: string): string;

package/dist/daemon/review/deliver.js

@@ -0,0 +1,3 @@
+var o=Object.defineProperty;var d=(e,n)=>o(e,"name",{value:n,configurable:!0});function i(e,n){return`${e.document_name!==null?e.changed?`The user reviewed and approved \`${e.document_name}\`. Their edits are saved as a new revision; re-read it with \`crtr canvas read ${e.document_name}\` before continuing. Review conversation: node \`${e.companion_node_id}\`.`:`The user reviewed and approved \`${e.document_name}\`. The document was not modified.`:e.changed?`The user reviewed and approved \`${e.file}\`. The document changed during review; re-read it before continuing. Review conversation: node \`${e.companion_node_id}\`.`:`The user reviewed and approved \`${e.file}\`. The document was not modified.`}
+
+Durable review result: ${n}`}d(i,"renderApprovalMessage");export{i as renderApprovalMessage};