@north-light/crouter 0.3.239 → 0.3.241

package/dist/core/wake.js

@@ -43,8 +43,9 @@ function whenError(code, message, received) {
 function cadenceError(code, message, received) {
     return { error: { code, message, received } };
 }
-/** Total ms for a relative-duration string, or null if it is not one. */
-function parseDurationMs(s) {
+/** Total ms for a relative-duration string (`90s`, `10m`, `1h30m`), or null if
+ * it is not one. */
+export function parseDurationMs(s) {
     if (!DURATION_RE.test(s))
         return null;
     let total = 0;

package/dist/daemon/crtrd.js

@@ -62,6 +62,7 @@ import { CronLaneReconciler } from './reconcilers/cron-lane.js';
 import { HumanDeliveryLaneReconciler } from './reconcilers/human-delivery-lane.js';
 import { PendingReviewSubmitReconciler } from './reconcilers/pending-review-submit.js';
 import { StorageMaintenanceReconciler } from './reconcilers/storage-maintenance.js';
+import { BashDeadlineReconciler } from './reconcilers/bash-deadline.js';
 import { captureLivenessSnapshot, capturePidCommand, captureTeardownSnapshot, isPidAlive, killProcessTreePids, } from '../core/canvas/pid.js';
 import { bindFleet, boundFleet } from '../core/runtime/fleet.js';
 import { bindDaemonControl, clearDaemonControl } from './control.js';
@@ -276,6 +277,7 @@ const cronLane = new CronLaneReconciler();
 const humanDeliveryLane = new HumanDeliveryLaneReconciler();
 const pendingReviewSubmit = new PendingReviewSubmitReconciler();
 const storageMaintenance = new StorageMaintenanceReconciler();
+const bashDeadline = new BashDeadlineReconciler();
 /** Supervision tick over the daemon's current live set. */
 export async function superviseTick(now = Date.now(), lifecycle = directTickLifecycle) {
     const fleet = boundFleet();
@@ -304,6 +306,7 @@ export async function superviseTick(now = Date.now(), lifecycle = directTickLife
     humanDeliveryLane.run(now, { lifecycle });
     pendingReviewSubmit.run(now, { lifecycle });
     storageMaintenance.run(now, {});
+    await bashDeadline.run(now, { rows });
     // Last: the saturation figure is only true once the freeze lane has spent
     // this tick's free slots.
     brokerSupervision.warnIfSaturated({ fleet, lifecycle, thresholds, frozen });

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

@@ -0,0 +1,17 @@
+import type { NodeRow } from '../../core/canvas/index.js';
+export interface BashDeadlineContext {
+    rows: NodeRow[];
+}
+/** Cancel AUTO-backgrounded bash jobs whose claim-or-cancel deadline has passed.
+ *
+ * The valve backgrounds a command it could not finish waiting for and arms a
+ * deadline the owning node must extend (`crtr node bash extend`) to keep the job
+ * alive. This lane is the enforcer: it survives a broker restart and fires while
+ * the node is idle, so a runaway command cannot outlive its window just because
+ * the agent moved on. A deliberately backgrounded job carries no deadline and is
+ * never touched here. */
+export declare class BashDeadlineReconciler {
+    private lastScanAt;
+    run(now: number, ctx: BashDeadlineContext): Promise<void>;
+    private cancel;
+}

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

@@ -0,0 +1,73 @@
+import { bashJobPaths, expiredAutoBackgroundBashJobs, formatBashElapsed, stopBackgroundBashJob, } from '../../core/bash-jobs.js';
+import { isSafeNodeId } from '../../core/canvas/paths.js';
+import { contextDir } from '../../core/canvas/paths.js';
+import { appendInbox } from '../../core/feed/inbox.js';
+import { emitEvent } from '../../core/events/emit.js';
+import { operationIdContext } from '../../core/events/operation-id.js';
+// How often the deadline scan runs. The valve arms a 60s default deadline, so a
+// few seconds of enforcement latency is immaterial; scanning every tick would
+// readdir every node's jobs dir needlessly.
+const SCAN_INTERVAL_MS = 5 * 1000;
+/** Cancel AUTO-backgrounded bash jobs whose claim-or-cancel deadline has passed.
+ *
+ * The valve backgrounds a command it could not finish waiting for and arms a
+ * deadline the owning node must extend (`crtr node bash extend`) to keep the job
+ * alive. This lane is the enforcer: it survives a broker restart and fires while
+ * the node is idle, so a runaway command cannot outlive its window just because
+ * the agent moved on. A deliberately backgrounded job carries no deadline and is
+ * never touched here. */
+export class BashDeadlineReconciler {
+    lastScanAt = Number.NEGATIVE_INFINITY;
+    async run(now, ctx) {
+        if (now - this.lastScanAt < SCAN_INTERVAL_MS)
+            return;
+        this.lastScanAt = now;
+        // A dead node's supervisor was already reaped with its broker; its jobs
+        // cannot still be live, and its inbox notice would reach no one.
+        for (const row of ctx.rows) {
+            if (row.status === 'dead')
+                continue;
+            const dir = contextDir(row.node_id);
+            let expired;
+            try {
+                expired = expiredAutoBackgroundBashJobs(dir, now);
+            }
+            catch (err) {
+                operationIdContext.fresh(() => {
+                    emitEvent({ level: 'error', event: 'bash_deadline.scan_failed', ...(isSafeNodeId(row.node_id) ? { node_id: row.node_id } : {}), error: err });
+                });
+                continue;
+            }
+            for (const job of expired) {
+                await this.cancel(row.node_id, dir, job.jobId, now - job.startedAtMs);
+            }
+        }
+    }
+    async cancel(nodeId, dir, jobId, elapsedMs) {
+        const stopped = await stopBackgroundBashJob(dir, jobId);
+        // Only a job we actually signaled earns a notice; a retired/missing job
+        // finished or was stopped by another path and already reported itself.
+        if (stopped.kind !== 'stopped')
+            return;
+        const paths = bashJobPaths(dir, jobId);
+        operationIdContext.fresh(() => {
+            try {
+                emitEvent({ level: 'info', event: 'bash_deadline.canceled', ...(isSafeNodeId(nodeId) ? { node_id: nodeId } : {}), fields: { job_id: jobId } });
+                appendInbox(nodeId, {
+                    from: null,
+                    tier: 'urgent',
+                    kind: 'urgent',
+                    label: 'background bash job canceled at its deadline',
+                    data: {
+                        body: `Background bash job ${jobId} was canceled after ${formatBashElapsed(elapsedMs)} because its background deadline passed and you did not claim it. ` +
+                            `Next time, give a long command more room up front (a larger inline timeout), or claim the job with \`crtr node bash extend ${jobId} --for <duration>\` before the deadline. ` +
+                            `Log: ${paths.jobLog}  Command: ${paths.cmdSh}`,
+                    },
+                });
+            }
+            catch (err) {
+                emitEvent({ level: 'error', event: 'bash_deadline.notice_failed', ...(isSafeNodeId(nodeId) ? { node_id: nodeId } : {}), error: err, fields: { job_id: jobId } });
+            }
+        });
+    }
+}

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

@@ -24,13 +24,13 @@
 // Deviation from upstream: this backend pins `bash` as the shell (upstream
 // consults user shell config via non-exported helpers). Acceptable — crtr's
 // agents are bash-contract anyway.
-import { envBashValveMs, envNodeId } from '../shared/env.js';
+import { envBashAutoBgDeadlineMs, envBashValveMs, envNodeId } from '../shared/env.js';
 import { spawn } from 'node:child_process';
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose } from '../core/bash-jobs.js';
+import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, 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';
@@ -257,7 +257,20 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                 };
                 function finishBackground(auto = false) {
                     const elapsed = formatBashElapsed(performance.now() - startedAt);
+                    // An AUTO handoff (the agent did not choose to background this) is a
+                    // runaway risk: arm a cancel deadline the daemon enforces, and tell
+                    // the agent to claim it or lose it. A deliberate handoff runs to
+                    // completion as before — no deadline file, so the daemon skips it.
+                    let deadlineNotice = '';
+                    if (auto) {
+                        const deadlineMs = envBashAutoBgDeadlineMs();
+                        writeJobDeadlineMs(paths, Date.now() + deadlineMs);
+                        deadlineNotice =
+                            `It will be CANCELED in ${formatBashElapsed(deadlineMs)} unless you claim it: ` +
+                                `crtr node bash extend ${paths.jobId} --for <duration> (or --keep to run to completion). `;
+                    }
                     const notice = `\n[backgrounded as job ${paths.jobId} after ${elapsed} in the foreground${auto ? ' (auto)' : ''}. ` +
+                        deadlineNotice +
                         `It will interrupt you with a message when it exits. ` +
                         `Watch: tail -f ${paths.jobLog} ; stop: kill -- -${pgid}]`;
                     onData(Buffer.from(notice));

package/dist/shared/env.d.ts

@@ -30,6 +30,10 @@ export declare function envRecapModelOverride(): string | undefined;
  *  default; undocumented test-only override so the E2E valve check doesn't
  *  sleep 5 minutes. */
 export declare function envBashValveMs(): number;
+/** How long an AUTO-backgrounded bash job may run before the daemon cancels it
+ *  unless the agent claims it (`CRTR_BASH_AUTO_BG_DEADLINE_MS`), 60s by default;
+ *  undocumented test-only override so the deadline check doesn't wait a minute. */
+export declare function envBashAutoBgDeadlineMs(): number;
 /** Explicit pidfile path override (`CRTR_PIDFILE`, tests only); undefined if
  *  unset or blank. */
 export declare function envPidfileOverride(): string | undefined;

package/dist/shared/env.js

@@ -92,6 +92,13 @@ const DEFAULT_BASH_VALVE_MS = 5 * 60 * 1000;
 export function envBashValveMs() {
     return parsePositiveMs(process.env['CRTR_BASH_VALVE_MS'], DEFAULT_BASH_VALVE_MS);
 }
+const DEFAULT_BASH_AUTO_BG_DEADLINE_MS = 60 * 1000;
+/** How long an AUTO-backgrounded bash job may run before the daemon cancels it
+ *  unless the agent claims it (`CRTR_BASH_AUTO_BG_DEADLINE_MS`), 60s by default;
+ *  undocumented test-only override so the deadline check doesn't wait a minute. */
+export function envBashAutoBgDeadlineMs() {
+    return parsePositiveMs(process.env['CRTR_BASH_AUTO_BG_DEADLINE_MS'], DEFAULT_BASH_AUTO_BG_DEADLINE_MS);
+}
 /** Explicit pidfile path override (`CRTR_PIDFILE`, tests only); undefined if
  *  unset or blank. */
 export function envPidfileOverride() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.239",
+  "version": "0.3.241",
   "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.239",
+  "version": "0.3.241",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.239",
+      "version": "0.3.241",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/dist/commands/sys/context/admin/axes-panel.d.ts

@@ -1,21 +0,0 @@
-import { type Snapshot } from './model.js';
-export type AxisId = 'event' | 'payload' | 'kind' | 'mode' | 'lifecycle' | 'manager' | 'depth' | 'profile' | 'cwd';
-interface Axis {
-    id: AxisId;
-    label: string;
-    value: string;
-    /** Free-text axes open a field; the rest cycle in place. */
-    typed: boolean;
-}
-/** The rail's rows for a snapshot. The payload row appears only for the events
- *  that read one, because on boot there is nothing it could change. */
-export declare function axesOf(snapshot: Snapshot, profileName: string): Axis[];
-/** Cycle one enum axis, returning the changed snapshot. A typed axis is never
- *  cycled — the shell opens a field for it instead. */
-export declare function cycleAxis(snapshot: Snapshot, id: AxisId, delta: number): Snapshot;
-/** Apply a typed axis's submitted value. */
-export declare function setTypedAxis(snapshot: Snapshot, id: AxisId, value: string): Snapshot;
-/** The value a typed axis's field is seeded with. */
-export declare function typedAxisValue(snapshot: Snapshot, id: AxisId): string;
-export declare function renderAxes(axes: Axis[], index: number, width: number, height: number, focused: boolean): string[];
-export {};