@north-light/crouter 0.3.193 → 0.3.195

package/dist/commands/node/bash.js

@@ -78,7 +78,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, started_at, elapsed_ms, log_path, pgid, log_tail} for every live background job.' },
+            { 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.' },
         ],
         outputKind: 'object',
         effects: ['Reads the node context jobs directory. Changes nothing.'],
@@ -95,6 +95,7 @@ const nodeBashList = defineLeaf({
         const jobs = activeBackgroundBashJobs(dir).map((job) => ({
             job_id: job.jobId,
             command: job.command,
+            purpose: job.purpose,
             started_at: new Date(job.startedAtMs).toISOString(),
             elapsed_ms: now - job.startedAtMs,
             log_path: job.logPath,
@@ -107,7 +108,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)} · ${job.command.split('\n')[0]}\n  log: ${job.log_path}`).join('\n');
+        return jobs.map((job) => `${job.job_id} · ${formatBashElapsed(job.elapsed_ms)} · ${job.command.split('\n')[0]}${job.purpose === null ? '' : `\n  purpose: ${job.purpose}`}\n  log: ${job.log_path}`).join('\n');
     },
 });
 const nodeBashKill = defineLeaf({

package/dist/commands/node/lifecycle.js

@@ -130,7 +130,7 @@ export const nodeConfig = defineLeaf({
             { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Target node id. Defaults to the node in --pane, else CRTR_NODE_ID.' },
             { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id to resolve the node from. Defaults to $TMUX_PANE.' },
             { kind: 'flag', name: 'model', type: 'string', required: false, constraint: 'Model spec: exact provider/id, capability tier (ultra|strong|medium|light), family alias (opus|sonnet|haiku), or a free-text substring when the broker is live. Dormant nodes require a provider/id, tier, or alias.' },
-            { kind: 'flag', name: 'lifecycle', type: 'enum', choices: ['terminal', 'resident'], required: false, constraint: 'Set lifecycle headlessly without closing the viewer. terminal owes a final and reaps when done; resident stays interactable and wakes on inbox/human.' },
+            { kind: 'flag', name: 'lifecycle', type: 'enum', choices: ['terminal', 'resident'], required: false, constraint: 'Set lifecycle headlessly without closing the viewer. terminal owes a final and reaps when done; resident stays interactable while attached or awaiting something live.' },
             { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Persona kind. The <kinds> list below names every top-level installable kind and when to use each; a sub-kind (e.g. plan/reviewers/security) is valid too by exact path but not listed here.' },
             { kind: 'flag', name: 'mode', type: 'enum', choices: ['base', 'orchestrator'], required: false, constraint: 'Set persona mode headlessly. base is hands-on; orchestrator holds a roadmap and delegates. orchestrator seeds a roadmap scaffold if absent.' },
             { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Rename the node; if the node has a live window, also rename that viewer window.' },
@@ -242,7 +242,7 @@ export const nodePromote = defineLeaf({
         summary: 'promote yourself to an orchestrator when worthwhile parallel delegation should make coordination your primary job; task duration, sequential phases, or one helper do not qualify. Mode only — lifecycle stays as-is unless you pass --resident',
         params: [
             { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Specialize as this kind of orchestrator. The <kinds> list below names every top-level installable kind and when to use each; a sub-kind (e.g. plan/reviewers/security) is valid too by exact path but not listed here. For an exact composed persona list, use `crtr sys prompt-review --list --kind <kind>` with the target kind. Defaults to your current kind. Promoting from a generic kind? CHOOSE a concrete one — it sets the orchestrator persona you revive into.' },
-            { kind: 'flag', name: 'resident', type: 'bool', required: false, constraint: 'ALSO flip lifecycle→resident: make the node interactable — it stays dormant, woken by inbox/human, and is never forced to submit a final. Omit to stay terminal/orchestrator (delegates + holds a roadmap, but still owes a final up the spine and reaps when done).' },
+            { kind: 'flag', name: 'resident', type: 'bool', required: false, constraint: 'ALSO flip lifecycle→resident: make the node interactable — it is never forced to submit a final, stays wakeable while attached or awaiting something live, and completes after the unattended grace otherwise. Omit to stay terminal/orchestrator (delegates + holds a roadmap, but still owes a final up the spine and reaps when done).' },
             { kind: 'flag', name: 'model', type: 'enum', choices: ['ultra', 'strong'], required: false, constraint: 'Change the model you run on, by capability tier: `ultra` (frontier — reserve for high-taste judgment or enormous work: speccing, planning something large, e2e-testing something hard to test) or `strong` (opus — regular dev work). Omit to keep your current model. An orchestrator steering work is never weaker than opus, so these are the only two choices; the change is durable across future revives.' },
             { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to promote. Defaults to the caller (CRTR_NODE_ID).' },
         ],

package/dist/core/__tests__/seam/dormancy-release.test.js

@@ -6,10 +6,10 @@
 //  (1) Issue #222/#353 — a real idle-release cycle must settle the inbox watcher
 //      before the broker exits, and the daemon may only revive for a row strictly
 //      after the committed cursor.
-//  (2) The observed 57-broker / ~5.4GB leak — a boot-revived settled node that
-//      receives no new work must still traverse bounded release: DAEMON
-//      SUPERVISION, not an agent event, owns the unattended park clock, and the
-//      exit policy frees the fleet slot without reviving.
+//  (2) The observed 57-broker / ~5.4GB leak — DAEMON SUPERVISION, not an agent
+//      event, owns the unattended clock. A resident with no live obligation
+//      completes into prunable history; one awaiting a child remains wakeable.
+//      Both release their broker and fleet slot.
 //
 // Both drive a real broker process through the real watcher/supervision paths, so
 // they belong to the compiled seam tier; neither needs tmux.
@@ -110,7 +110,20 @@ test('idle-release settles its real watcher before exit; daemon revives exactly
     await h.tick();
     assert.equal(h.node(manager).cycles ?? 0, cyclesAfterRelease + 1, 'the settled later row does not cause a duplicate revival');
 });
-test('a revived settled node with no work releases on the daemon park clock and leaves no broker', { timeout: 30_000 }, async () => {
+test('an already idle resident with no live obligation reconciles into completed history', async () => {
+    const nodeId = h.fabricateBrokerNode({
+        id: 'idle-resident-without-obligation',
+        parent: root,
+        lifecycle: 'resident',
+        status: 'idle',
+        intent: 'idle-release',
+        pi_session_id: 'parked-session',
+    });
+    await h.tick();
+    assert.equal(h.node(nodeId)?.status, 'done', 'an older idle row becomes pruning-eligible without needing a broker revive');
+    assert.equal(h.node(nodeId)?.intent, 'done', 'the reconciled row records clean completion');
+});
+test('an unattended resident with no live obligation completes on the daemon clock', { timeout: 30_000 }, async () => {
     // The park clock is read per supervision pass (unattendedParkMsForDaemon), so
     // it is armed for THIS test only — a file-global 1500ms park clock would also
     // apply to the idle-release manager above and race its own release path.
@@ -120,6 +133,7 @@ test('a revived settled node with no work releases on the daemon park clock and
         const nodeId = h.fabricateBrokerNode({
             id: 'settled-no-work',
             parent: root,
+            lifecycle: 'resident',
             status: 'idle',
             intent: 'idle-release',
         });
@@ -141,15 +155,55 @@ test('a revived settled node with no work releases on the daemon park clock and
         await h.tick(seenAt + 1500);
         await h.waitFor(() => {
             const node = h.node(nodeId);
-            return node?.status === 'idle' && node.intent === 'idle-release' && !isPidAlive(boot.pid);
-        }, { timeoutMs: 10_000, intervalMs: 20, label: 'park-clock release and broker exit' });
+            return node?.status === 'done' && node.intent === 'done' && !isPidAlive(boot.pid);
+        }, { timeoutMs: 10_000, intervalMs: 20, label: 'unattended completion and broker exit' });
         // The pid vanishing is not the fleet learning about it: wait for the child
         // 'exit' delivery + its policy job, which is what actually frees the slot.
         await h.awaitFleetExit(nodeId);
-        assert.equal(h.fleet.has(nodeId), false, 'exit policy forgets the idle-release broker');
-        assert.equal(h.node(nodeId)?.intent, 'idle-release', 'the row remains durably dormant');
+        assert.equal(h.fleet.has(nodeId), false, 'exit policy forgets the completed broker');
+        assert.equal(h.node(nodeId)?.status, 'done', 'the row is terminal and eligible for history pruning');
         await h.tick();
-        assert.equal(h.fleet.has(nodeId), false, 'a supervision tick does not revive without inbox work');
+        assert.equal(h.fleet.has(nodeId), false, 'a supervision tick does not revive completed history');
+    }
+    finally {
+        if (priorParkMs === undefined)
+            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+        else
+            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
+    }
+});
+test('an unattended resident awaiting a live child remains wakeable', { timeout: 30_000 }, async () => {
+    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
+    try {
+        const nodeId = h.fabricateBrokerNode({
+            id: 'settled-awaiting-child',
+            parent: root,
+            lifecycle: 'resident',
+            status: 'idle',
+            intent: 'idle-release',
+        });
+        const child = h.fabricateBrokerNode({ parent: nodeId, status: 'idle', intent: 'idle-release' });
+        subscribe(nodeId, child, true);
+        updateNode(nodeId, {
+            launch: {
+                extensions: [],
+                tools: [],
+                systemPrompt: '',
+                env: {},
+            },
+        });
+        reviveNode(nodeId, { resume: true });
+        const boot = await h.awaitBoot(nodeId);
+        const seenAt = 20_000;
+        await h.tick(seenAt);
+        await h.tick(seenAt + 1500);
+        await h.waitFor(() => {
+            const node = h.node(nodeId);
+            return node?.status === 'idle' && node.intent === 'idle-release' && !isPidAlive(boot.pid);
+        }, { timeoutMs: 10_000, intervalMs: 20, label: 'awaiting resident release and broker exit' });
+        await h.awaitFleetExit(nodeId);
+        assert.equal(h.node(nodeId)?.status, 'idle', 'a live child keeps the resident eligible for an automatic wake');
     }
     finally {
         if (priorParkMs === undefined)

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

@@ -12,7 +12,13 @@ export interface BashJobPaths {
      * Inspector's cancel) — without it on disk, only the agent's own handoff
      * notice knows the group to signal. */
     jobPgid: string;
+    /** Human-readable label supplied with the bash call, when any. */
+    jobPurpose: 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
+ * cannot inject control content into terminal or JSON presenters. */
+export declare function normalizeBashJobPurpose(value: unknown): string | null;
 export declare function bashJobsDir(contextDir: string): string;
 /** Whether a job id can safely be used as one path segment. Generated ids are
  * numeric epoch prefixes plus a hex suffix; this broader safe alphabet keeps
@@ -22,6 +28,9 @@ export declare function bashJobPaths(contextDir: string, jobId: string): BashJob
 /** The job's supervisor process group, or undefined for a job started before
  * pgid was persisted (or a partially-written dir). */
 export declare function readJobPgid(contextDir: string, jobId: string): number | undefined;
+/** 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;
 /** 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. */
@@ -72,6 +81,8 @@ export interface BashJobStatus {
     jobId: string;
     /** Full text of cmd.sh. */
     command: string;
+    /** Human-readable label, or null for an unlabeled or legacy job. */
+    purpose: string | null;
     startedAtMs: number;
     logPath: string;
 }

package/dist/core/bash-jobs.js

@@ -5,6 +5,18 @@
 import { randomBytes } from 'node:crypto';
 import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, renameSync, 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
+ * plane to one bounded, visible line so old or hand-written job directories
+ * cannot inject control content into terminal or JSON presenters. */
+export function normalizeBashJobPurpose(value) {
+    if (typeof value !== 'string' || /[\p{Cc}\p{Cf}]/u.test(value))
+        return null;
+    const purpose = value.trim();
+    if (purpose === '')
+        return null;
+    return Buffer.byteLength(purpose, 'utf8') <= MAX_BASH_JOB_PURPOSE_BYTES ? purpose : null;
+}
 export function bashJobsDir(contextDir) {
     return join(contextDir, 'jobs');
 }
@@ -29,6 +41,7 @@ export function bashJobPaths(contextDir, jobId) {
         jobBg: join(dir, 'job.bg'),
         jobDone: join(dir, 'job.done'),
         jobPgid: join(dir, 'job.pgid'),
+        jobPurpose: join(dir, 'purpose'),
     };
 }
 /** The job's supervisor process group, or undefined for a job started before
@@ -42,6 +55,16 @@ export function readJobPgid(contextDir, jobId) {
         return undefined;
     }
 }
+/** The optional human-readable job label. Jobs created before labels existed
+ * have no file and deliberately project null. */
+export function readJobPurpose(contextDir, jobId) {
+    try {
+        return normalizeBashJobPurpose(readFileSync(bashJobPaths(contextDir, jobId).jobPurpose, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
 /** 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. */
@@ -193,7 +216,7 @@ export function activeBackgroundBashJobs(contextDir) {
         catch {
             continue;
         }
-        jobs.push({ jobId, command, startedAtMs, logPath: paths.jobLog });
+        jobs.push({ jobId, command, purpose: readJobPurpose(contextDir, jobId), startedAtMs, logPath: paths.jobLog });
     }
     return jobs.sort((a, b) => a.startedAtMs - b.startedAtMs);
 }

package/dist/core/canvas/types.d.ts

@@ -11,7 +11,8 @@
  *  only `dead` is a fault. */
 export type NodeStatus = 'active' | 'idle' | 'done' | 'dead' | 'canceled';
 /** Does stopping finalize the node? terminal = worker (finalizes on push --final);
- *  resident = manager/orchestrator (stays dormant, woken by inbox). */
+ *  resident = interactable while attached or holding a live obligation. An
+ *  unattended obligation-free resident completes after the daemon grace. */
 export type Lifecycle = 'terminal' | 'resident';
 /** base = hands-on worker; orchestrator = delegating manager. Bespoke per kind. */
 export type Mode = 'base' | 'orchestrator';

package/dist/core/inspector/model.d.ts

@@ -4,6 +4,8 @@ export type InspectorSection = 'overview' | 'schedule' | 'jobs' | 'raw';
 export interface BashJobRow {
     job_id: string;
     command: string;
+    /** Human-readable label supplied with the bash call, or null when absent. */
+    purpose: string | null;
     started_at: string;
     elapsed_ms: number;
     log_path: string;
@@ -67,6 +69,9 @@ export declare function jobElapsedMs(job: BashJobRow, now?: number): number;
 export declare function jobElapsed(job: BashJobRow, now?: number): string;
 /** First line of a command, whitespace-collapsed and capped for a one-row cell. */
 export declare function commandCell(command: string, cap?: number): string;
+/** A person-readable purpose leads when present; legacy jobs retain their
+ * command label. */
+export declare function jobLabel(job: BashJobRow, cap?: number): string;
 export declare function relativeTime(iso: string | null, now?: number): string;
 /** How long ago an ISO timestamp was, e.g. `3d ago`. `—` when absent. */
 export declare function ago(iso: unknown, now?: number): string;

package/dist/core/inspector/model.js

@@ -81,6 +81,11 @@ export function commandCell(command, cap = 60) {
     const oneLine = (command.split('\n')[0] ?? '').replace(/\s+/g, ' ').trim();
     return oneLine.length > cap ? `${oneLine.slice(0, cap - 1)}…` : oneLine;
 }
+/** A person-readable purpose leads when present; legacy jobs retain their
+ * command label. */
+export function jobLabel(job, cap = 60) {
+    return commandCell(job.purpose ?? job.command, cap);
+}
 export function relativeTime(iso, now = Date.now()) {
     if (iso === null)
         return '—';

package/dist/core/inspector/text.js

@@ -1,4 +1,4 @@
-import { jobElapsed, overviewGroups, relativeTime, scheduledItems, value } from './model.js';
+import { jobElapsed, jobLabel, overviewGroups, relativeTime, scheduledItems, value } from './model.js';
 /** The piped path: same information and grouping as the TUI, minus the glyphs
  *  and hue a pipe cannot carry. */
 export const inspectorText = {
@@ -36,7 +36,7 @@ export const inspectorText = {
         if (jobs.length === 0)
             lines.push('  nothing running');
         for (const job of jobs) {
-            lines.push('', `  ${job.command.split('\n')[0]} · ${jobElapsed(job)}`, `    id        ${job.job_id}`, `    started   ${job.started_at}`, `    log       ${job.log_path}`);
+            lines.push('', `  ${jobLabel(job)} · ${jobElapsed(job)}`, `    id        ${job.job_id}`, ...(job.purpose === null ? [] : [`    command   ${job.command.split('\n')[0]}`]), `    started   ${job.started_at}`, `    log       ${job.log_path}`);
             for (const line of job.log_tail.slice(-5))
                 lines.push(`    | ${line}`);
         }

package/dist/core/inspector/tui.js

@@ -1,4 +1,4 @@
-import { ICON, commandCell, jobElapsed, jobElapsedMs, jobTone, overviewGroups, relativeTime, scheduledItems, shortPath, value, } from './model.js';
+import { ICON, commandCell, jobElapsed, jobElapsedMs, jobLabel, jobTone, overviewGroups, relativeTime, scheduledItems, shortPath, value, } from './model.js';
 // ── Visual grammar ───────────────────────────────────────────────────────────
 //
 // Three primitives carry the whole screen: a TAB STRIP (where am I / where can
@@ -162,7 +162,14 @@ function jobItem(job, expanded, width) {
         lines.push([{ text: `${INDENT}${INDENT}${last === undefined ? 'no output yet' : logCell(last, width - 6)}`, style: { dim: true } }]);
     }
     else {
-        for (const [label, text] of [['job', job.job_id], ['started', job.started_at], ['log', shortPath(job.log_path)], ['watch', `tail -f ${shortPath(job.log_path)}`]]) {
+        const details = [
+            ['job', job.job_id],
+            ...(job.purpose === null ? [] : [['command', commandCell(job.command, Math.max(20, width - 26))]]),
+            ['started', job.started_at],
+            ['log', shortPath(job.log_path)],
+            ['watch', `tail -f ${shortPath(job.log_path)}`],
+        ];
+        for (const [label, text] of details) {
             lines.push([{ text: `${INDENT}${INDENT}${label.padEnd(LABEL_COL)}`, style: LABEL_STYLE }, { text, style: label === 'watch' ? { fg: '36' } : undefined }]);
         }
         lines.push([]);
@@ -176,7 +183,7 @@ function jobItem(job, expanded, width) {
     return {
         spans: [
             { text: ` ${ICON.job} `, style: tone },
-            { text: commandCell(job.command, Math.max(20, width - 26)), style: { bold: true } },
+            { text: jobLabel(job, Math.max(20, width - 26)), style: { bold: true } },
         ],
         right: [{ text: `${jobElapsed(job)} `, style: tone }],
         lines,

package/dist/core/keybindings/catalog.d.ts

@@ -1,6 +1,6 @@
 import type { BindingDefinition, SafetyRequirement } from './types.js';
 import type { AttachBindingId, AttachMenuBindingId } from './attach-control.js';
-type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools' | 'metadata' | 'promote' | 'resume' | 'fork' | 'demote' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'providers' | 'plugins' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
+type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools' | 'metadata' | 'promote' | 'demote-mode' | 'resume' | 'fork' | 'demote' | 'make-resident' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'providers' | 'plugins' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
 type TmuxMenuEntryAction = Exclude<TmuxMenuAction, 'open' | 'attach'> | `issue.${'idea' | 'bug'}`;
 type GraphAction = 'down' | 'up' | 'first' | 'last' | 'collapse-or-manager' | 'expand-or-child' | 'focus' | 'revive' | 'focus-manager' | 'close-subtree' | 'dismiss';
 type BrowseAction = 'quit' | 'down' | 'up' | 'first' | 'last' | 'expand-or-child' | 'collapse-or-parent' | 'toggle-fold' | 'tab-next' | 'tab-previous' | `tab.${1 | 2 | 3 | 4 | 5}` | 'close-subtree' | 'confirm-close' | 'sort' | 'scope' | 'profile' | 'residents' | 'preview' | 'search' | 'revive-now' | 'focus' | 'focus-background';

package/dist/core/keybindings/catalog.js

@@ -38,10 +38,12 @@ const SETUP_TAB_CONTEXTS = ['setup.login', 'setup.list', 'setup.keybindings', 's
 export const BINDING_CATALOG = Object.freeze([
     b('crtr.tmux.menu.open', 'Global tmux', 'Open crouter menu', 'Open the crouter action menu.', ['alt+c'], 'host-global', ['tmux.root']),
     b('crtr.tmux.menu.attach', 'Global tmux', 'Attach actions', 'Open the attach-viewer action submenu.', ['a'], 'tmux-menu-selector', ['tmux.menu']),
-    ...menuEntry('promote', 'Promote node', 'Promote the focused node to orchestrator.', ['o'], ['tmux.menu']),
+    ...menuEntry('promote', 'Promote to orchestrator', 'Promote the focused node to orchestrator — it holds a roadmap and delegates.', ['o'], ['tmux.menu']),
+    ...menuEntry('demote-mode', 'Demote to base node', 'Demote the focused orchestrator back to a base node — hands-on again in its own window, no roadmap to drive.', ['shift+o'], ['tmux.menu']),
     ...menuEntry('resume', 'Find node', 'Open the canvas navigator and go to the chosen node.', ['/'], ['tmux.menu']),
     ...menuEntry('fork', 'Fork node', 'Fork the focused node into an independent idle root.', ['f'], ['tmux.menu']),
-    ...menuEntry('demote', 'Demote node', 'Demote the focused node to terminal — it keeps running, owes a final up the spine, and reaps when done.', ['d'], ['tmux.menu']),
+    ...menuEntry('demote', 'Demote to terminal', 'Demote the focused node to terminal — it keeps running, owes a final up the spine, and reaps when done.', ['d'], ['tmux.menu']),
+    ...menuEntry('make-resident', 'Make resident', 'Flip the focused node to resident — interactable, never forced to submit a final, and wakeable while attached or awaiting something live.', ['shift+r'], ['tmux.menu']),
     ...menuEntry('detach', 'Demote and close viewer', 'Demote the focused node and close its viewer; its broker keeps running off-screen.', ['shift+d'], ['tmux.menu']),
     ...menuEntry('close-subtree', 'Close subtree', 'Close the focused node and its subtree.', ['x'], ['tmux.menu']),
     ...menuEntry('background-bash', 'Background running bash', 'Hand the focused node’s running bash command to its background job system.', ['b'], ['tmux.menu']),

package/dist/core/runtime/persona.js

@@ -4,7 +4,8 @@
 //   • mode      — base (hands-on; yields mode-preservingly when another window is needed) ↔ orchestrator
 //                 (delegates, holds a roadmap, survives refresh cycles + yields)
 //   • lifecycle — terminal (owes a final up the spine, reaps when done) ↔
-//                 resident (interactable, stays dormant, never forced to submit)
+//                 resident (interactable, never forced to submit; unattended
+//                 obligation-free conversations complete after the daemon grace)
 //
 // Whenever EITHER axis changes from the value the node was last GIVEN guidance
 // for, the node must be prompt-injected with guidance for its new state —

package/dist/core/runtime/tmux-bindings.js

@@ -19,7 +19,12 @@ const LEAF_MENU_ACTIONS = {
     'crtr.tmux.menu.promote': { description: 'promote to orchestrator', action: { kind: 'keys', keys: '/promote' } },
     'crtr.tmux.menu.resume': { description: 'find node', action: { kind: 'keys', keys: '/resume-node' } },
     'crtr.tmux.menu.fork': { description: 'fork into idle root', action: { kind: 'direct', run: 'node fork --pane {pane}' } },
-    'crtr.tmux.menu.demote': { description: 'demote (finish when done)', action: { kind: 'command', run: 'node lifecycle demote --pane {pane}' } },
+    // Mode demote is the mirror of `/promote`: `node config` is the durable
+    // attribute setter, and the persona injector delivers the hands-on-again
+    // guidance at the node's next turn boundary.
+    'crtr.tmux.menu.demote-mode': { description: 'demote to base node', action: { kind: 'command', run: 'node config --mode base --pane {pane}' } },
+    'crtr.tmux.menu.demote': { description: 'demote to terminal (finish when done)', action: { kind: 'command', run: 'node lifecycle demote --pane {pane}' } },
+    'crtr.tmux.menu.make-resident': { description: 'make resident (interactable)', action: { kind: 'command', run: 'node config --lifecycle resident --pane {pane}' } },
     'crtr.tmux.menu.detach': { description: 'demote + close viewer', action: { kind: 'command', run: 'node lifecycle demote --pane {pane} --detach' } },
     'crtr.tmux.menu.close-subtree': { description: 'close agent + subtree', action: { kind: 'command', run: 'node lifecycle close --pane {pane}' } },
     'crtr.tmux.menu.background-bash': { description: 'background running bash', action: { kind: 'direct', run: 'node bash background --pane {pane}' } },
@@ -296,7 +301,9 @@ function menuItems(bindings, entries) {
     addGroup('Lifecycle', boundItems([
         'crtr.tmux.menu.fork',
         'crtr.tmux.menu.promote',
+        'crtr.tmux.menu.demote-mode',
         'crtr.tmux.menu.demote',
+        'crtr.tmux.menu.make-resident',
         'crtr.tmux.menu.detach',
         'crtr.tmux.menu.close-subtree',
     ]));

package/dist/core/termrender/version.d.ts

@@ -1 +1 @@
-export declare const TERMRENDER_VERSION = "4.12.6";
+export declare const TERMRENDER_VERSION = "4.12.7";

package/dist/core/termrender/version.js

@@ -1 +1 @@
-export const TERMRENDER_VERSION = '4.12.6';
+export const TERMRENDER_VERSION = '4.12.7';

package/dist/daemon/api/handlers/bash-jobs.js

@@ -35,6 +35,7 @@ function handleList(ctx) {
         return {
             job_id: job.jobId,
             command: job.command,
+            purpose: job.purpose,
             started_at: new Date(job.startedAtMs).toISOString(),
             elapsed_ms: Math.max(0, now - job.startedAtMs),
             pgid,

package/dist/daemon/reconcilers/broker-supervision.js

@@ -20,6 +20,7 @@ import { operationIdContext } from '../../core/events/operation-id.js';
 import { readCursor, readInboxSince } from '../../core/feed/inbox.js';
 import { activeBackgroundBashJobs } from '../../core/bash-jobs.js';
 import { focusOf } from '../../core/runtime/placement.js';
+import { hasLiveObligation } from './live-obligation.js';
 const execFileAsync = promisify(execFile);
 function configuredPositiveInteger(name, fallback) {
     const raw = process.env[name];
@@ -205,7 +206,12 @@ export class BrokerSupervisionReconciler {
         if (now - since < unattendedParkMsForDaemon())
             return;
         this.unattendedSince.delete(id);
-        transition(id, 'release');
+        const liveObligation = hasLiveObligation(id);
+        // A resident with nothing left to wake it has completed its conversation:
+        // terminalize it so history retention can eventually prune it. A resident
+        // still awaiting a child/controller/human/deadline/output stays wakeable, as does
+        // every terminal node (whose own stop guard owns semantic completion).
+        transition(id, row.lifecycle === 'resident' && !liveObligation ? 'finish' : 'release');
         headlessBrokerHost.teardown(id);
     }
     async warnOverCapInTmux(count, warning, max) {

package/dist/daemon/reconcilers/dormant-inbox.js

@@ -7,6 +7,7 @@ import { appendControllerDeathNotice, readCursor, readInboxSince, } from '../../
 import { fanDoctrineWake } from '../../core/runtime/close.js';
 import { transition } from '../../core/runtime/lifecycle.js';
 import { reviveNode } from '../../core/runtime/revive.js';
+import { hasLiveObligation } from './live-obligation.js';
 // Idle-release/inbox retry cap (2026-07-10 diagnosis, round 2): the SAME
 // livelock shape as the stranded-relaunch case, but on the separate pass that
 // resumes a dormant idle-released node when its inbox gains an unseen entry.
@@ -78,6 +79,13 @@ export class DormantInboxReconciler {
                     // set neither revives the node nor starts a stuck-relaunch episode.
                     if (!entries.some((entry) => entry.tier !== 'deferred')) {
                         this.relaunchState.delete(id);
+                        const meta = getNode(id);
+                        // An idle resident with no wake-worthy inbox entry still needs
+                        // lifecycle settlement. Once nothing live remains, this is completed
+                        // history rather than a permanently protected idle row.
+                        if (meta?.lifecycle === 'resident' && !hasLiveObligation(id)) {
+                            transition(id, 'finish');
+                        }
                         return;
                     }
                     const prior = this.relaunchState.get(id);

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

@@ -0,0 +1,2 @@
+/** Durable work that requires a resident to remain automatically wakeable. */
+export declare function hasLiveObligation(nodeId: string): boolean;

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

@@ -0,0 +1,11 @@
+import { hasActiveLiveSubscription, hasLiveMessageWait, hasPendingCancelOnWakeCron, } from '../../core/canvas/index.js';
+import { countTickets } from '../../core/canvas/attention.js';
+import { readOutputRequest } from '../../core/runtime/structured-output.js';
+/** Durable work that requires a resident to remain automatically wakeable. */
+export function hasLiveObligation(nodeId) {
+    return hasActiveLiveSubscription(nodeId)
+        || hasLiveMessageWait(nodeId)
+        || hasPendingCancelOnWakeCron(nodeId)
+        || countTickets(nodeId) > 0
+        || readOutputRequest(nodeId).state !== 'absent';
+}