@north-light/crouter 0.3.300 → 0.3.302

package/dist/daemon/delivery/run-delivery.js

@@ -0,0 +1,164 @@
+// One process contract for every durable delivery crouter retries: spawn the
+// declared target, hand it the document on stdin, and settle the attempt from
+// its exit code. Human-request completions and node outcomes differ only in the
+// row they settle, so both call this and neither reimplements the protocol.
+import { spawn } from 'node:child_process';
+import { envHomeOverride } from '../../shared/env.js';
+import { deliveryBackoffMs } from '../../core/canvas/delivery-contract.js';
+import { killProcessGroup } from '../../core/canvas/pid.js';
+import { buildOperationalEnvBase } from '../../core/runtime/spawn-env.js';
+export const DELIVERY_TIMEOUT_MS = 120_000;
+const DELIVERY_KILL_GRACE_MS = 2_000;
+export const DELIVERY_STDERR_TAIL_BYTES = 4 * 1024;
+/** Process contract mapping. stdout deliberately does not participate. */
+export function deliverySettlementForOutcome(outcome, attempt, now) {
+    if (outcome.spawnError !== undefined) {
+        return {
+            state: 'pending',
+            nextAttemptAt: now + deliveryBackoffMs(attempt),
+            failure: failure('spawn_error', { message: outcome.spawnError.message, stderr: outcome.stderr }),
+        };
+    }
+    if (outcome.timedOut) {
+        return {
+            state: 'pending',
+            nextAttemptAt: now + deliveryBackoffMs(attempt),
+            // The kill escalation's own signal distinguishes the graceful term from the SIGKILL.
+            failure: failure('timeout', { ...(outcome.signal === null ? {} : { signal: outcome.signal }), stderr: outcome.stderr }),
+        };
+    }
+    if (outcome.signal !== null) {
+        return {
+            state: 'pending',
+            nextAttemptAt: now + deliveryBackoffMs(attempt),
+            failure: failure('signal', { signal: outcome.signal, stderr: outcome.stderr }),
+        };
+    }
+    if (outcome.exitCode === 0)
+        return { state: 'accepted' };
+    if (outcome.exitCode === 78) {
+        return { state: 'permanent_failed', failure: failure('exit', { exitCode: 78, stderr: outcome.stderr }) };
+    }
+    return {
+        state: 'pending',
+        nextAttemptAt: now + deliveryBackoffMs(attempt),
+        failure: failure('exit', { exitCode: outcome.exitCode ?? undefined, stderr: outcome.stderr }),
+    };
+}
+function failure(kind, fields) {
+    return { kind, ...fields };
+}
+function stderrTailCapture() {
+    let tail = Buffer.alloc(0);
+    return {
+        take(chunk) {
+            tail = chunk.length >= DELIVERY_STDERR_TAIL_BYTES
+                ? chunk.subarray(chunk.length - DELIVERY_STDERR_TAIL_BYTES)
+                : Buffer.concat([tail, chunk]).subarray(Math.max(0, tail.length + chunk.length - DELIVERY_STDERR_TAIL_BYTES));
+        },
+        decode() {
+            return tail.toString('utf8');
+        },
+    };
+}
+/** The stored document is immutable; attempt is its only per-delivery mutation. */
+function documentForAttempt(document, attempt) {
+    const stored = document;
+    const delivery = stored.delivery;
+    return JSON.stringify({ ...stored, delivery: { ...delivery, attempt } });
+}
+/** The delivery child crosses the same consent boundary as every other
+ *  crouter spawn: nothing of crtrd's own environment reaches it except what
+ *  `spawnEnv.allow` and the operational base admit for the target's own cwd.
+ *  No profile participates — a delivery target is declared in scope config alone. */
+function deliveryEnv(cwd) {
+    const env = buildOperationalEnvBase({ targetCwd: cwd, targetProfileId: null });
+    // Runtime identity, not host state: a target that calls `crtr` must reach
+    // the daemon that delivered to it, exactly as a cron body does.
+    const canvasHome = envHomeOverride();
+    if (canvasHome !== undefined && canvasHome !== '')
+        env['CRTR_HOME'] = canvasHome;
+    return env;
+}
+/** Spawn and settle one already-claimed delivery. `settle` writes the outcome
+ *  to whichever durable row owns this attempt. */
+export async function runDelivery(job, settle) {
+    const stderr = stderrTailCapture();
+    let document;
+    try {
+        document = documentForAttempt(job.document, job.attempt);
+    }
+    catch (error) {
+        settle(deliverySettlementForOutcome({
+            exitCode: null,
+            signal: null,
+            timedOut: false,
+            spawnError: error,
+            stderr: stderr.decode(),
+        }, job.attempt, Date.now()));
+        return;
+    }
+    let child;
+    try {
+        child = spawn(job.argv[0], job.argv.slice(1), {
+            cwd: job.cwd,
+            env: deliveryEnv(job.cwd),
+            detached: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        settle(deliverySettlementForOutcome({
+            exitCode: null,
+            signal: null,
+            timedOut: false,
+            spawnError: error,
+            stderr: stderr.decode(),
+        }, job.attempt, Date.now()));
+        return;
+    }
+    await new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let killTimer;
+        let timeout;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            // A timed-out leader can exit while a SIGTERM-ignoring group member remains.
+            if (!outcome.timedOut && killTimer !== undefined)
+                clearTimeout(killTimer);
+            child.stdin?.destroy();
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            settle(deliverySettlementForOutcome(outcome, job.attempt, Date.now()));
+            resolve();
+        };
+        child.stdout?.on('data', () => { }); // Drain output; stdout is never a control channel.
+        child.stderr?.on('data', (chunk) => stderr.take(chunk));
+        child.stdin?.on('error', () => { }); // The child may exit before consuming stdin; its exit code is authoritative.
+        child.on('error', (error) => {
+            finish({ exitCode: null, signal: null, timedOut: false, spawnError: error, stderr: stderr.decode() });
+        });
+        child.on('exit', (exitCode, signal) => {
+            finish({ exitCode, signal, timedOut, stderr: stderr.decode() });
+        });
+        const killWithEscalation = () => {
+            if (child.pid === undefined)
+                return;
+            killProcessGroup(child.pid);
+            killTimer = setTimeout(() => killProcessGroup(child.pid, 'SIGKILL'), DELIVERY_KILL_GRACE_MS);
+            killTimer.unref?.();
+        };
+        // The deadline starts at spawn, not after stdin write or any output.
+        timeout = setTimeout(() => {
+            timedOut = true;
+            killWithEscalation();
+        }, DELIVERY_TIMEOUT_MS);
+        timeout.unref?.();
+        child.stdin?.end(document, 'utf8');
+    });
+}

package/dist/daemon/human/deliver-action.d.ts

@@ -1,16 +1,3 @@
-import { type ActionDeliveryRecord, type ActionDeliverySettlement } from '../../core/canvas/human-deliveries.js';
-export declare const ACTION_DELIVERY_TIMEOUT_MS = 120000;
-export declare const ACTION_DELIVERY_STDERR_TAIL_BYTES: number;
-/** Durable exponential retry delay for the attempt that just failed. */
-export declare function actionDeliveryBackoffMs(attempt: number): number;
-export interface ActionDeliveryProcessOutcome {
-    exitCode: number | null;
-    signal: string | null;
-    timedOut: boolean;
-    spawnError?: Error;
-    stderr: string;
-}
-/** Process contract mapping. stdout deliberately does not participate. */
-export declare function actionDeliverySettlementForOutcome(outcome: ActionDeliveryProcessOutcome, attempt: number, now: number): ActionDeliverySettlement;
+import { type ActionDeliveryRecord } from '../../core/canvas/human-deliveries.js';
 /** Spawn and settle one already-claimed action delivery. */
 export declare function deliverAction(delivery: ActionDeliveryRecord, claimOwner: string): Promise<void>;

package/dist/daemon/human/deliver-action.js

@@ -1,169 +1,9 @@
-import { envHomeOverride } from '../../shared/env.js';
-import { spawn } from 'node:child_process';
+// Delivery of one settled human request to its declared completion action.
+// The process contract lives in `daemon/delivery/run-delivery.ts`; this file
+// binds it to the action-delivery row.
 import { settleActionDelivery, } from '../../core/canvas/human-deliveries.js';
-import { killProcessGroup } from '../../core/canvas/pid.js';
-import { buildOperationalEnvBase } from '../../core/runtime/spawn-env.js';
-export const ACTION_DELIVERY_TIMEOUT_MS = 120_000;
-const ACTION_DELIVERY_KILL_GRACE_MS = 2_000;
-export const ACTION_DELIVERY_STDERR_TAIL_BYTES = 4 * 1024;
-/** Durable exponential retry delay for the attempt that just failed. */
-export function actionDeliveryBackoffMs(attempt) {
-    return Math.min(5_000 * 2 ** (attempt - 1), 3_600_000);
-}
-/** Process contract mapping. stdout deliberately does not participate. */
-export function actionDeliverySettlementForOutcome(outcome, attempt, now) {
-    if (outcome.spawnError !== undefined) {
-        return {
-            state: 'pending',
-            nextAttemptAt: now + actionDeliveryBackoffMs(attempt),
-            failure: failure('spawn_error', { message: outcome.spawnError.message, stderr: outcome.stderr }),
-        };
-    }
-    if (outcome.timedOut) {
-        return {
-            state: 'pending',
-            nextAttemptAt: now + actionDeliveryBackoffMs(attempt),
-            // The kill escalation's own signal distinguishes the graceful term from the SIGKILL.
-            failure: failure('timeout', { ...(outcome.signal === null ? {} : { signal: outcome.signal }), stderr: outcome.stderr }),
-        };
-    }
-    if (outcome.signal !== null) {
-        return {
-            state: 'pending',
-            nextAttemptAt: now + actionDeliveryBackoffMs(attempt),
-            failure: failure('signal', { signal: outcome.signal, stderr: outcome.stderr }),
-        };
-    }
-    if (outcome.exitCode === 0)
-        return { state: 'accepted' };
-    if (outcome.exitCode === 78) {
-        return { state: 'permanent_failed', failure: failure('exit', { exitCode: 78, stderr: outcome.stderr }) };
-    }
-    return {
-        state: 'pending',
-        nextAttemptAt: now + actionDeliveryBackoffMs(attempt),
-        failure: failure('exit', { exitCode: outcome.exitCode ?? undefined, stderr: outcome.stderr }),
-    };
-}
-function failure(kind, fields) {
-    return { kind, ...fields };
-}
-function stderrTailCapture() {
-    let tail = Buffer.alloc(0);
-    return {
-        take(chunk) {
-            tail = chunk.length >= ACTION_DELIVERY_STDERR_TAIL_BYTES
-                ? chunk.subarray(chunk.length - ACTION_DELIVERY_STDERR_TAIL_BYTES)
-                : Buffer.concat([tail, chunk]).subarray(Math.max(0, tail.length + chunk.length - ACTION_DELIVERY_STDERR_TAIL_BYTES));
-        },
-        decode() {
-            return tail.toString('utf8');
-        },
-    };
-}
-function completionForAttempt(completion, attempt) {
-    const document = completion;
-    const delivery = document.delivery;
-    return JSON.stringify({ ...document, delivery: { ...delivery, attempt } });
-}
+import { runDelivery } from '../delivery/run-delivery.js';
 /** Spawn and settle one already-claimed action delivery. */
 export async function deliverAction(delivery, claimOwner) {
-    const stderr = stderrTailCapture();
-    let completion;
-    try {
-        completion = completionForAttempt(delivery.completion, delivery.attempt);
-    }
-    catch (error) {
-        settle(delivery, claimOwner, actionDeliverySettlementForOutcome({
-            exitCode: null,
-            signal: null,
-            timedOut: false,
-            spawnError: error,
-            stderr: stderr.decode(),
-        }, delivery.attempt, Date.now()));
-        return;
-    }
-    let child;
-    try {
-        child = spawn(delivery.argv[0], delivery.argv.slice(1), {
-            cwd: delivery.cwd,
-            env: actionDeliveryEnv(delivery.cwd),
-            detached: true,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-    }
-    catch (error) {
-        settle(delivery, claimOwner, actionDeliverySettlementForOutcome({
-            exitCode: null,
-            signal: null,
-            timedOut: false,
-            spawnError: error,
-            stderr: stderr.decode(),
-        }, delivery.attempt, Date.now()));
-        return;
-    }
-    await new Promise((resolve) => {
-        let settled = false;
-        let timedOut = false;
-        let killTimer;
-        let timeout;
-        const finish = (outcome) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timeout !== undefined)
-                clearTimeout(timeout);
-            if (killTimer !== undefined)
-                clearTimeout(killTimer);
-            child.stdin?.destroy();
-            child.stdout?.destroy();
-            child.stderr?.destroy();
-            settle(delivery, claimOwner, actionDeliverySettlementForOutcome(outcome, delivery.attempt, Date.now()));
-            resolve();
-        };
-        child.stdout?.on('data', () => { }); // Drain diagnostics; stdout is never a control channel.
-        child.stderr?.on('data', (chunk) => stderr.take(chunk));
-        child.stdin?.on('error', () => { }); // A child may exit before draining a large completion; its exit code remains authoritative.
-        child.on('error', (error) => {
-            finish({ exitCode: null, signal: null, timedOut: false, spawnError: error, stderr: stderr.decode() });
-        });
-        child.on('exit', (exitCode, signal) => {
-            finish({
-                exitCode,
-                signal,
-                timedOut,
-                stderr: stderr.decode(),
-            });
-        });
-        const killWithEscalation = () => {
-            if (child.pid === undefined)
-                return;
-            killProcessGroup(child.pid);
-            killTimer = setTimeout(() => killProcessGroup(child.pid, 'SIGKILL'), ACTION_DELIVERY_KILL_GRACE_MS);
-            killTimer.unref?.();
-        };
-        // The deadline starts at spawn, not after stdin write or any output.
-        timeout = setTimeout(() => {
-            timedOut = true;
-            killWithEscalation();
-        }, ACTION_DELIVERY_TIMEOUT_MS);
-        timeout.unref?.();
-        child.stdin?.end(completion, 'utf8');
-    });
-}
-/** The delivery child crosses the same consent boundary as every other
- *  crouter spawn: nothing of crtrd's own environment reaches it except what
- *  `spawnEnv.allow` and the operational base admit for the action's own cwd.
- *  No profile participates — an action is declared in scope config alone. */
-function actionDeliveryEnv(cwd) {
-    const env = buildOperationalEnvBase({ targetCwd: cwd, targetProfileId: null });
-    // Runtime identity, not host state: an action that calls `crtr` must reach
-    // the daemon that delivered to it, exactly as a cron body does.
-    const canvasHome = envHomeOverride();
-    if (canvasHome !== undefined && canvasHome !== '')
-        env['CRTR_HOME'] = canvasHome;
-    return env;
-}
-function settle(delivery, claimOwner, settlement) {
-    settleActionDelivery(delivery.requestId, delivery.attempt, claimOwner, settlement, Date.now());
+    await runDelivery({ argv: delivery.argv, cwd: delivery.cwd, document: delivery.completion, attempt: delivery.attempt }, (settlement) => settleActionDelivery(delivery.requestId, delivery.attempt, claimOwner, settlement, Date.now()));
 }

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { newestReportRef, hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPendingCancelOnWakeCron, subscribersOf, } from '../../core/canvas/index.js';
+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, readCursor, readInboxSince } from '../../core/feed/inbox.js';
@@ -12,7 +12,7 @@ import { transition } from '../../core/runtime/lifecycle.js';
 export function hasLiveObligation(nodeId) {
     return hasActiveLiveSubscription(nodeId)
         || hasLiveMessageWait(nodeId)
-        || hasPendingCancelOnWakeCron(nodeId)
+        || hasPendingCronWake(nodeId)
         || countTickets(nodeId) > 0
         || readOutputRequest(nodeId).state !== 'absent';
 }

package/dist/pi-extensions/canvas-bash-valve.js

@@ -30,7 +30,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmS
 import { homedir } from 'node:os';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, writeJobDeadlineMs } from '../core/bash-jobs.js';
+import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, readBashNiceness, writeJobDeadlineMs } from '../core/bash-jobs.js';
 import { readConfig } from '../core/config.js';
 import { PREVIEW_RESULT_PATH_ENV, previewResultPath } from '../core/preview-result-path.js';
 import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
@@ -50,23 +50,20 @@ function resolveValveMs() {
 // lives only in cmd.sh):
 //   $1 cmd.sh     $2 job.log   $3 job.exit   $4 job.run
 //   $5 job.done   $6 job.bg    $7 jobId      $8 nodeId      $9 shell path
+//   ${10} niceness
 //
 // `--` before the paths is a dummy $0 (a standard `bash -c script -- args`
 // idiom) so the real payload lands at $1 onward.
 // The elapsed rendering mirrors formatBashElapsed() in core/bash-jobs.ts
 // (`12s` / `3m 40s` / `1h 04m`) so the completion message reads the same as the
 // handoff notice; it measures TOTAL runtime, foreground portion included.
-/** Niceness of every command an agent runs. Agent work — builds, test suites,
- *  typechecks — sits below the daemon, the brokers, the viewers, and the
- *  person's own shell, so a fan-out of release builds cannot starve them: the
- *  scheduler only honors this under contention and it costs nothing on an idle
- *  host. Only the command is niced; the supervisor that reports its finish
- *  runs at normal priority so completion notices stay prompt. */
-const COMMAND_NICENESS = 10;
+// Only the command is niced (at ${10}, the node's own niceness); the supervisor
+// that reports its finish runs at normal priority so completion notices stay
+// prompt.
 const SUPERVISOR_SCRIPT = [
     'SECONDS=0',
     'n=$(command -v nice)',
-    `\${n:+"$n" -n ${COMMAND_NICENESS}} "\${9}" "$1" > "$2" 2>&1`,
+    '${n:+"$n" -n "${10}"} "${9}" "$1" > "$2" 2>&1',
     'ec=$?',
     'd=$SECONDS',
     'echo "$ec" > "$3"',
@@ -337,7 +334,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     childEnv = { ...childEnv, [PREVIEW_RESULT_PATH_ENV]: previewPath };
                 }
                 const shellPath = resolveAdmittedHostCommand('bash', childEnv, execution.cwd);
-                const child = spawn(shellPath, ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId, shellPath], {
+                const child = spawn(shellPath, ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId, shellPath, String(readBashNiceness(contextDir))], {
                     cwd: execution.cwd,
                     detached: true,
                     stdio: 'ignore',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.300",
+  "version": "0.3.302",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.300",
+  "version": "0.3.302",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.300",
+      "version": "0.3.302",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.300",
+      "version": "0.3.302",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.300",
+      "version": "0.3.302",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.300",
+      "version": "0.3.302",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"