@north-light/crouter 0.3.239 → 0.3.240

package/dist/commands/node/bash.js

@@ -4,7 +4,9 @@ import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { displayMessage } from '../../core/runtime/tmux-chrome.js';
 import { contextDir } from '../../core/canvas/paths.js';
-import { activeBackgroundBashJobs, backgroundRunningBashJobs, bashJobCommandLine, bashJobPaths, formatBashElapsed, isSafeBashJobId, jobStartedAtMs, readJobPgid, stopBackgroundBashJob, tailJobLog } from '../../core/bash-jobs.js';
+import { existsSync } from 'node:fs';
+import { activeBackgroundBashJobs, backgroundRunningBashJobs, bashJobCommandLine, bashJobPaths, clearJobDeadline, formatBashElapsed, isSafeBashJobId, jobStartedAtMs, readJobPgid, stopBackgroundBashJob, tailJobLog, writeJobDeadlineMs } from '../../core/bash-jobs.js';
+import { parseDurationMs } from '../../core/wake.js';
 import { cliClient, getNodeOrNull } from '../api-client.js';
 import { nodeInPane } from '../surface/node/placement.js';
 function resolveBashTarget(input, missingMessage) {
@@ -77,7 +79,7 @@ const nodeBashList = defineLeaf({
         ],
         output: [
             { name: 'node_id', type: 'string', required: true, constraint: 'The target node.' },
-            { name: 'jobs', type: 'object[]', required: true, constraint: 'Oldest-first {job_id, command, purpose, started_at, elapsed_ms, log_path, pgid, log_tail} for every live background job; purpose is a human-readable label or null.' },
+            { name: 'jobs', type: 'object[]', required: true, constraint: 'Oldest-first {job_id, command, purpose, started_at, elapsed_ms, deadline_at, log_path, pgid, log_tail} for every live background job; purpose is a human-readable label or null; deadline_at is the auto-cancel time or null for a job that runs to completion.' },
         ],
         outputKind: 'object',
         effects: ['Reads the node context jobs directory. Changes nothing.'],
@@ -97,6 +99,7 @@ const nodeBashList = defineLeaf({
             purpose: job.purpose,
             started_at: new Date(job.startedAtMs).toISOString(),
             elapsed_ms: now - job.startedAtMs,
+            deadline_at: job.deadlineAtMs === null ? null : new Date(job.deadlineAtMs).toISOString(),
             log_path: job.logPath,
             pgid: readJobPgid(dir, job.jobId) ?? null,
             log_tail: tailJobLog(job.logPath, tail),
@@ -107,7 +110,7 @@ const nodeBashList = defineLeaf({
         const jobs = result['jobs'];
         if (jobs.length === 0)
             return `No background bash jobs for ${result['node_id']}.`;
-        return jobs.map((job) => `${job.job_id} · ${formatBashElapsed(job.elapsed_ms)} · ${bashJobCommandLine(job.command)}${job.purpose === null ? '' : `\n  purpose: ${job.purpose}`}\n  log: ${job.log_path}`).join('\n');
+        return jobs.map((job) => `${job.job_id} · ${formatBashElapsed(job.elapsed_ms)} · ${bashJobCommandLine(job.command)}${job.purpose === null ? '' : `\n  purpose: ${job.purpose}`}${job.deadline_at === null ? '' : `\n  cancels at: ${job.deadline_at}`}\n  log: ${job.log_path}`).join('\n');
     },
 });
 const nodeBashKill = defineLeaf({
@@ -171,14 +174,75 @@ const nodeBashKill = defineLeaf({
     },
     render: (result) => `Canceled a background bash job for ${result['node_id']}${result['signaled'] === true ? '' : ' (its process group was already gone)'}.`,
 });
+const nodeBashExtend = defineLeaf({
+    name: 'extend',
+    description: 'claim an auto-backgrounded bash job so the daemon does not cancel it at its deadline',
+    whenToUse: 'a command the valve auto-backgrounded is worth keeping past its cancel deadline — give it more time with --for, or let it run to completion with --keep',
+    tier: 'hidden',
+    help: {
+        name: 'node bash extend',
+        summary: 'move or clear the auto-cancel deadline on one of a node’s live background bash jobs',
+        params: [
+            { kind: 'positional', name: 'job', required: true, constraint: 'Job id, as reported by node bash list or the auto-background notice.' },
+            { kind: 'flag', name: 'for', type: 'string', required: false, constraint: 'New window from now before the job is canceled, as a duration (e.g. 90s, 10m, 1h30m). Mutually exclusive with --keep; give exactly one.' },
+            { kind: 'flag', name: 'keep', type: 'bool', required: false, constraint: 'Remove the deadline entirely so the job runs to completion. Mutually exclusive with --for; give exactly one.' },
+            { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node owning the job. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
+            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane showing the target node, when --node is omitted. Defaults to $TMUX_PANE.' },
+        ],
+        output: [
+            { name: 'node_id', type: 'string', required: true, constraint: 'The owning node.' },
+            { name: 'deadline_at', type: 'string', required: false, constraint: 'The job’s new auto-cancel time (ISO), or absent when --keep cleared the deadline so the job runs to completion.' },
+        ],
+        outputKind: 'object',
+        effects: ['Rewrites or removes the job’s deadline file. The daemon’s deadline lane reads it on its next scan. Signals nothing.'],
+    },
+    run: async (input) => {
+        const { id } = resolveBashTarget(input, 'no node found for the bash job');
+        const node = await getNodeOrNull(id);
+        if (node === null) {
+            throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
+        }
+        const jobId = input['job'];
+        if (!isSafeBashJobId(jobId)) {
+            throw new InputError({ error: 'invalid_job_id', message: `invalid background job id: ${jobId}`, next: 'Use a job id reported by `crtr node bash list`.' });
+        }
+        const forDuration = input['for'];
+        const keep = input['keep'] === true;
+        if (keep === (forDuration !== undefined && forDuration !== '')) {
+            throw new InputError({ error: 'invalid_args', message: 'give exactly one of --for <duration> or --keep', next: 'Extend by a window with --for 10m, or drop the deadline with --keep.' });
+        }
+        const dir = contextDir(node.node_id);
+        const paths = bashJobPaths(dir, jobId);
+        if (!existsSync(paths.dir)) {
+            throw new InputError({ error: 'not_found', message: `no background job ${jobId} for ${node.node_id}`, next: 'List live jobs with `crtr node bash list`.' });
+        }
+        if (!existsSync(paths.jobBg) || existsSync(paths.jobExit)) {
+            throw new InputError({ error: 'not_running', message: `background job ${jobId} for ${node.node_id} is no longer running`, next: `It finished or was stopped, so there is no deadline to change. Log: ${paths.jobLog}` });
+        }
+        if (keep) {
+            clearJobDeadline(paths);
+            return { node_id: node.node_id };
+        }
+        const durationMs = parseDurationMs(forDuration);
+        if (durationMs === null || durationMs <= 0) {
+            throw new InputError({ error: 'invalid_duration', message: `not a duration: ${forDuration}`, next: 'Use a value like 90s, 10m, or 1h30m.' });
+        }
+        const deadlineMs = Date.now() + durationMs;
+        writeJobDeadlineMs(paths, deadlineMs);
+        return { node_id: node.node_id, deadline_at: new Date(deadlineMs).toISOString() };
+    },
+    render: (result) => result['deadline_at'] === undefined
+        ? `Cleared the deadline — the background job will run to completion for ${result['node_id']}.`
+        : `Background job for ${result['node_id']} will be canceled at ${result['deadline_at']} unless extended again.`,
+});
 export const nodeBash = defineBranch({
     name: 'bash',
     description: 'control file-backed bash jobs owned by a node',
-    whenToUse: 'a running bash command must be handed off, listed, or stopped — the tmux prefix menu backgrounds, the Inspector’s jobs section lists and cancels',
+    whenToUse: 'a running bash command must be handed off, listed, stopped, or its auto-cancel deadline changed — the tmux prefix menu backgrounds, the Inspector’s jobs section lists and cancels',
     tier: 'hidden',
     help: {
         name: 'node bash',
         summary: 'control file-backed bash jobs owned by a node',
     },
-    children: [nodeBashBackground, nodeBashList, nodeBashKill],
+    children: [nodeBashBackground, nodeBashList, nodeBashKill, nodeBashExtend],
 });

package/dist/commands/sys/context/admin.js

@@ -10,6 +10,7 @@ import { ApiError } from '../../../api/index.js';
 import { cliClient } from '../../api-client.js';
 import { SURFACE_EVENTS } from '../../../core/substrate/schema.js';
 import { ambientMemoryTarget } from '../../../core/memory-resolver.js';
+import { getDefaultProfileId } from '../../../core/profiles/default-binding.js';
 import { resolveProfileOperand } from '../../../core/profiles/manifest.js';
 export const adminLeaf = defineLeaf({
     name: 'admin',
@@ -49,15 +50,16 @@ export const adminLeaf = defineLeaf({
         const ambient = ambientMemoryTarget();
         const profileId = input['profile']?.trim();
         const cwd = input['cwd']?.trim();
+        const resolvedCwd = cwd === undefined || cwd === '' ? (node?.cwd ?? ambient.cwd) : resolvePath(cwd);
         const seed = {
             kind: input['kind']?.trim() || node?.kind || 'general',
             mode: input['mode'] ?? node?.mode ?? 'base',
             lifecycle: node?.lifecycle ?? 'terminal',
             hasManager: node?.parent != null,
             profileId: profileId === undefined || profileId === ''
-                ? (node?.profile_id ?? ambient.profileId)
+                ? (node?.profile_id ?? ambient.profileId ?? getDefaultProfileId(resolvedCwd))
                 : resolveProfileOperand(profileId).profileId,
-            cwd: cwd === undefined || cwd === '' ? (node?.cwd ?? ambient.cwd) : resolvePath(cwd),
+            cwd: resolvedCwd,
             nodeId: node?.node_id ?? null,
             depth: node === null ? 0 : await spineDepth(node),
             event: (input['event'] ?? 'boot'),

package/dist/commands/sys/context/resolve.js

@@ -23,6 +23,7 @@ import { clearSessionCache } from '../../../core/substrate/session-cache.js';
 import { rungAtLeast, SURFACE_EVENTS, } from '../../../core/substrate/schema.js';
 import { scopeForCwd, profileNameFor } from '../../../core/substrate/subject-fields.js';
 import { resetScopeCache } from '../../../core/scope.js';
+import { getDefaultProfileId } from '../../../core/profiles/default-binding.js';
 export const resolveLeaf = defineLeaf({
     name: 'resolve',
     description: 'resolve what a configuration snapshot loads for one surface event',
@@ -95,7 +96,10 @@ export async function buildSnapshot(input) {
         ?? derived?.lifecycle
         ?? (mode === 'orchestrator' ? 'resident' : 'terminal');
     const cwd = resolveCwd(optionalString(input['cwd']) ?? derived?.cwd ?? process.cwd());
-    const profileId = optionalString(input['profile']) ?? node?.profile_id ?? ambientMemoryTarget().profileId;
+    const profileId = optionalString(input['profile'])
+        ?? node?.profile_id
+        ?? ambientMemoryTarget().profileId
+        ?? getDefaultProfileId(cwd);
     const hasManagerFlag = optionalString(input['hasManager']);
     return {
         subject: {

package/dist/core/bash-jobs.d.ts

@@ -14,6 +14,11 @@ export interface BashJobPaths {
     jobPgid: string;
     /** Human-readable label supplied with the bash call, when any. */
     jobPurpose: string;
+    /** Epoch-ms cancel deadline for an AUTO-backgrounded job. Present only when
+     * the valve backgrounded the job on its own; its presence marks the job as
+     * subject to the daemon's claim-or-cancel deadline. Absent for a deliberate
+     * handoff (tmux menu, broker termination), which runs to completion. */
+    jobDeadline: string;
 }
 /** A purpose is display text, never shell input. Keep the file-backed control
  * plane to one bounded, visible line so old or hand-written job directories
@@ -31,6 +36,17 @@ export declare function readJobPgid(contextDir: string, jobId: string): number |
 /** The optional human-readable job label. Jobs created before labels existed
  * have no file and deliberately project null. */
 export declare function readJobPurpose(contextDir: string, jobId: string): string | null;
+/** The auto-background cancel deadline (epoch ms), or undefined for a job with
+ * no deadline (a deliberate handoff, or a legacy job dir). A non-finite or
+ * malformed file reads as no deadline rather than an instant expiry. */
+export declare function readJobDeadlineMs(contextDir: string, jobId: string): number | undefined;
+/** Arm or move an auto-backgrounded job's cancel deadline to `deadlineMs`
+ * (epoch ms). Written by the valve at auto-handoff and rewritten when the
+ * owning node claims more time. */
+export declare function writeJobDeadlineMs(paths: BashJobPaths, deadlineMs: number): void;
+/** Drop a job's cancel deadline so it runs to completion — the node has claimed
+ * it. Best-effort: a job with no deadline file is already in this state. */
+export declare function clearJobDeadline(paths: BashJobPaths): void;
 /** Whether a persisted job supervisor process group is still present. EPERM
  *  means the group exists but cannot be signaled by this process; it is still
  *  live for the status surface. */
@@ -88,12 +104,19 @@ export interface BashJobStatus {
     purpose: string | null;
     startedAtMs: number;
     logPath: string;
+    /** Auto-background cancel deadline (epoch ms), or null for a job that runs to
+     * completion (a deliberate handoff, or one the node has claimed). */
+    deadlineAtMs: number | null;
 }
 /** Every live backgrounded bash job for this node — job.bg present, job.exit
  * absent — whether handed off by the menu, the valve deadline, or broker
  * termination. Read-only; never mutates. Skips malformed/partially-written
  * directories. Returns oldest-first by startedAtMs. */
 export declare function activeBackgroundBashJobs(contextDir: string): BashJobStatus[];
+/** Every live background job for this node whose auto-cancel deadline has
+ * passed at `now`. The daemon's deadline lane stops exactly these. A job with
+ * no deadline (deliberate handoff, or one the node claimed) never appears. */
+export declare function expiredAutoBackgroundBashJobs(contextDir: string, now: number): BashJobStatus[];
 export type BackgroundBashJobResult = 'backgrounded' | 'already-backgrounded' | 'finished' | 'missing';
 /** Atomically hand one foreground job to its detached supervisor. The rename
  * is the ownership decision: exactly one caller can move job.run to job.bg,

package/dist/core/bash-jobs.js

@@ -3,7 +3,7 @@
 // job.bg, while foreground completion renames it to job.done. The detached
 // supervisor can therefore outlive pi and still decide whether to report exit.
 import { randomBytes } from 'node:crypto';
-import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 const MAX_BASH_JOB_PURPOSE_BYTES = 280;
 /** A purpose is display text, never shell input. Keep the file-backed control
@@ -42,6 +42,7 @@ export function bashJobPaths(contextDir, jobId) {
         jobDone: join(dir, 'job.done'),
         jobPgid: join(dir, 'job.pgid'),
         jobPurpose: join(dir, 'purpose'),
+        jobDeadline: join(dir, 'job.deadline'),
     };
 }
 /** The job's supervisor process group, or undefined for a job started before
@@ -65,6 +66,34 @@ export function readJobPurpose(contextDir, jobId) {
         return null;
     }
 }
+/** The auto-background cancel deadline (epoch ms), or undefined for a job with
+ * no deadline (a deliberate handoff, or a legacy job dir). A non-finite or
+ * malformed file reads as no deadline rather than an instant expiry. */
+export function readJobDeadlineMs(contextDir, jobId) {
+    try {
+        const n = Number(readFileSync(bashJobPaths(contextDir, jobId).jobDeadline, 'utf8').trim());
+        return Number.isFinite(n) ? n : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Arm or move an auto-backgrounded job's cancel deadline to `deadlineMs`
+ * (epoch ms). Written by the valve at auto-handoff and rewritten when the
+ * owning node claims more time. */
+export function writeJobDeadlineMs(paths, deadlineMs) {
+    writeFileSync(paths.jobDeadline, `${Math.trunc(deadlineMs)}\n`);
+}
+/** Drop a job's cancel deadline so it runs to completion — the node has claimed
+ * it. Best-effort: a job with no deadline file is already in this state. */
+export function clearJobDeadline(paths) {
+    try {
+        rmSync(paths.jobDeadline, { force: true });
+    }
+    catch {
+        /* best-effort — worst case the daemon cancels it at the old deadline */
+    }
+}
 /** Whether a persisted job supervisor process group is still present. EPERM
  *  means the group exists but cannot be signaled by this process; it is still
  *  live for the status surface. */
@@ -222,10 +251,23 @@ export function activeBackgroundBashJobs(contextDir) {
         catch {
             continue;
         }
-        jobs.push({ jobId, command, purpose: readJobPurpose(contextDir, jobId), startedAtMs, logPath: paths.jobLog });
+        jobs.push({
+            jobId,
+            command,
+            purpose: readJobPurpose(contextDir, jobId),
+            startedAtMs,
+            logPath: paths.jobLog,
+            deadlineAtMs: readJobDeadlineMs(contextDir, jobId) ?? null,
+        });
     }
     return jobs.sort((a, b) => a.startedAtMs - b.startedAtMs);
 }
+/** Every live background job for this node whose auto-cancel deadline has
+ * passed at `now`. The daemon's deadline lane stops exactly these. A job with
+ * no deadline (deliberate handoff, or one the node claimed) never appears. */
+export function expiredAutoBackgroundBashJobs(contextDir, now) {
+    return activeBackgroundBashJobs(contextDir).filter((job) => job.deadlineAtMs !== null && now >= job.deadlineAtMs);
+}
 /** Atomically hand one foreground job to its detached supervisor. The rename
  * is the ownership decision: exactly one caller can move job.run to job.bg,
  * while the supervisor races to move the same source to job.done. */

package/dist/core/wake.d.ts

@@ -35,6 +35,9 @@ export type Recur = {
 };
 /** Cadence floor: reject any interval / cron min-spacing below this (AC-N4). */
 export declare const CADENCE_FLOOR_MS = 60000;
+/** Total ms for a relative-duration string (`90s`, `10m`, `1h30m`), or null if
+ * it is not one. */
+export declare function parseDurationMs(s: string): number | null;
 /**
  * Resolve a `<when>` to a single UTC `fireAt`:
  *   - relative duration (`90s`, `1h30m`)        -> now + Σ

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