@north-light/crouter 0.3.231 → 0.3.232

package/dist/commands/profile.js

@@ -2,8 +2,9 @@
 // identities defined at the user root, each owning a manifest naming project
 // directories plus its own memory store.
 //
-// Every manifest verb but `new`/`list` takes <profile> as an exact id OR a
-// unique manifest name.
+// Every manifest verb but `new`/`list` takes <profile> as an exact id, a
+// manifest name, or the closest match to one. `delete` is the one exception:
+// an irreversible verb never runs against a guessed target.
 import { defineBranch } from '../core/command.js';
 import { newLeaf } from './profile/new.js';
 import { listLeaf } from './profile/list.js';
@@ -27,7 +28,7 @@ export function registerProfile() {
         help: {
             name: 'profile',
             summary: 'create, inspect, and manage profiles \u2014 agent identities with their own project purview and memory store',
-            model: 'A profile owns a `home` — the first of its project dirs unless `project add --home` re-points it — which is where a node under the profile runs when its create names no directory at all. A node lands in the directory it was launched from when there is one: `node new --cwd`, an inherited spawner directory (notably inside a managed worktree), or the directory a root was started in. So one profile can cover many working directories — cwd selects the identity, and the launch decides where the work happens. `new` creates one from a name (+ at most one initial `--project`, which becomes its home). `list` inventories every profile as JSONL. `show` prints one manifest in full. `rename` changes only the manifest name \u2014 the profile_id is stable across a rename. `delete --force` removes the profile after cascading through its nodes, matching schedules, originating inbox/review state, and default pins; `--detach --force` instead preserves nodes and human history while clearing the profile identity and globalizing its schedules. Both modes block while a matching node owns an open managed worktree and never touch the project directories the profile pointed at. `project` widens/narrows a profile\u2019s project purview (the dirs it resolves memory + config from). `default` pins which profile a directory defaults to at startup so the chooser stops asking \u2014 directory-scoped, independent of purview. `env` manages a profile-scoped 0600 store of env vars injected directly into every broker launched under that profile \u2014 set on stdin, list names only (never values), or remove one; no `spawnEnv.allow` entry needed. `meta` edits the manifest\u2019s readable metadata map \u2014 identity facts each broker under the profile sees as `CRTR_PROFILE_META_<KEY>` env (secrets stay in `env`). Every manifest verb but `new`/`list` takes <profile> as an exact id or a unique manifest name; an ambiguous name fails listing every matching id.',
+            model: 'A profile owns a `home` — the first of its project dirs unless `project add --home` re-points it — which is where a node under the profile runs when its create names no directory at all. A node lands in the directory it was launched from when there is one: `node new --cwd`, an inherited spawner directory (notably inside a managed worktree), or the directory a root was started in. So one profile can cover many working directories — cwd selects the identity, and the launch decides where the work happens. `new` creates one from a name (+ at most one initial `--project`, which becomes its home). `list` inventories every profile as JSONL. `show` prints one manifest in full. `rename` changes only the manifest name \u2014 the profile_id is stable across a rename. `delete --force` removes the profile after cascading through its nodes, matching schedules, originating inbox/review state, and default pins; `--detach --force` instead preserves nodes and human history while clearing the profile identity and globalizing its schedules. Both modes block while a matching node owns an open managed worktree and never touch the project directories the profile pointed at. `project` widens/narrows a profile\u2019s project purview (the dirs it resolves memory + config from). `default` pins which profile a directory defaults to at startup so the chooser stops asking \u2014 directory-scoped, independent of purview. `env` manages a profile-scoped 0600 store of env vars injected directly into every broker launched under that profile \u2014 set on stdin, list names only (never values), or remove one; no `spawnEnv.allow` entry needed. `meta` edits the manifest\u2019s readable metadata map \u2014 identity facts each broker under the profile sees as `CRTR_PROFILE_META_<KEY>` env (secrets stay in `env`). Every manifest verb but `new`/`list` takes <profile> as an exact id, a manifest name, or a close-enough name that resolves to the nearest profile (reported on stderr); a name shared by several profiles, or one equally close to several, fails listing every matching id. `delete` alone never guesses — an irreversible verb requires an exact id or name.',
         },
         children: [newLeaf, listLeaf, showLeaf, renameLeaf, pauseLeaf, resumeLeaf, kindLeaf, metaLeaf, deleteLeaf, projectBranch, defaultBranch, envBranch],
     });

package/dist/commands/surface-tmux-spread.js

@@ -92,7 +92,6 @@ export const tmuxSpreadLeaf = defineLeaf({
         output: [
             { name: 'window', type: 'string', required: false, constraint: 'The new window id holding the tiled spread.' },
             { name: 'session', type: 'string', required: false, constraint: 'The session the spread window lives in (the caller\'s session — break-pane keeps it).' },
-            { name: 'panes', type: 'number', required: true, constraint: 'How many panes the spread window ended with (self + opened siblings).' },
             { name: 'nodes', type: 'string', required: true, constraint: 'Space-joined ids tiled into the window (self first).' },
             { name: 'overflow', type: 'number', required: true, constraint: 'Broker-alive siblings beyond the cap that were NOT shown.' },
         ],
@@ -207,7 +206,6 @@ export const tmuxSpreadLeaf = defineLeaf({
         return {
             window,
             session: session ?? undefined,
-            panes: spreadIds.length,
             nodes: spreadIds.join(' '),
             overflow,
         };
@@ -215,6 +213,6 @@ export const tmuxSpreadLeaf = defineLeaf({
     render: (out) => {
         const o = out;
         const tail = o.overflow > 0 ? ` (+${o.overflow} more not shown)` : '';
-        return `spread ${o.panes} pane(s) into window ${o.window ?? '?'}${tail}`;
+        return `spread viewers into window ${o.window ?? '?'}${tail}`;
     },
 });

package/dist/commands/sys/config.js

@@ -186,8 +186,7 @@ const configSet = defineLeaf({
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to write to. Default: user. Project scope is supported only for modelLadders.' },
         ],
         output: [
-            { name: 'key', type: 'string', required: true, constraint: 'Echo of input key.' },
-            { name: 'value', type: 'unknown', required: true, constraint: 'Value as written.' },
+            { name: 'value', type: 'unknown', required: true, constraint: 'Resolved value as written after parsing and setting-specific coercion.' },
             { name: 'scope', type: 'string', required: true, constraint: 'Scope the value was written to.' },
         ],
         outputKind: 'object',
@@ -210,9 +209,9 @@ const configSet = defineLeaf({
         const cfg = ladder !== null
             ? (persistModelLadders(requireScopeRoot(scope), ladder), readConfig(scope))
             : updateConfig(scope, (c) => setNestedValue(c, key, rawValue, parsed));
-        // Read back the written value for echo
+        // Read back the resolved value that was written
         const written = getNestedValue(cfg, key);
-        return { key, value: written, scope };
+        return { value: written, scope };
     },
 });
 const configPath = defineLeaf({

package/dist/commands/sys/support/prepare.js

@@ -212,10 +212,8 @@ export const supportPrepareLeaf = defineLeaf({
             },
         ],
         output: [
-            { name: 'status', type: 'string', required: true, constraint: 'Always "prepared" on success; every failure throws.' },
-            { name: 'reference', type: 'string', required: true, constraint: 'YYYYMMDDTHHmmssSSSZ-xxxxxxxx — pass this to `crtr sys support submit`.' },
+            { name: 'reference', type: 'string', required: true, constraint: 'Generated YYYYMMDDTHHmmssSSSZ-xxxxxxxx — pass this to `crtr sys support submit`.' },
             { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the new ~/.crouter/support/<reference>/ directory.' },
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node the bundle was collected for.' },
             { name: 'source_count', type: 'number', required: true, constraint: 'Number of distinct sources declared in the manifest.' },
             { name: 'bytes', type: 'number', required: true, constraint: 'Combined size of manifest.json + bundle.jsonl, always \u2264 2,097,152.' },
         ],
@@ -230,6 +228,12 @@ export const supportPrepareLeaf = defineLeaf({
         const nodeId = input['node_id'];
         if (nodeId === undefined || nodeId === '')
             throw usage('node_id is required. Run `crtr sys support prepare -h`.');
-        return prepareSupportBundle(nodeId);
+        const result = prepareSupportBundle(nodeId);
+        return {
+            reference: result.reference,
+            path: result.path,
+            source_count: result.source_count,
+            bytes: result.bytes,
+        };
     },
 });

package/dist/commands/sys/support/submit.js

@@ -504,8 +504,6 @@ export const supportSubmitLeaf = defineLeaf({
             },
         ],
         output: [
-            { name: 'status', type: 'string', required: true, constraint: 'Always "submitted" on success; every failure throws.' },
-            { name: 'reference', type: 'string', required: true, constraint: 'The submitted reference.' },
             { name: 'repository', type: 'string', required: true, constraint: 'Canonical owner/name of the private destination.' },
             { name: 'url', type: 'string', required: true, constraint: 'Canonical github.com URL of support/<reference>/.' },
         ],
@@ -520,6 +518,7 @@ export const supportSubmitLeaf = defineLeaf({
         const reference = input.reference;
         if (reference === undefined || reference === '')
             throw usage('reference is required. Run `crtr sys support submit -h`.');
-        return submitPreparedBundle(reference, process.env, defaultGhRunner);
+        const result = await submitPreparedBundle(reference, process.env, defaultGhRunner);
+        return { repository: result.repository, url: result.url };
     },
 });

package/dist/commands/sys/sync-deps.js

@@ -481,10 +481,6 @@ export const sysSyncDepsLeaf = defineLeaf({
             { kind: 'flag', name: 'dry-run', type: 'bool', required: false, constraint: 'Report what would be vendored without writing anything.' },
         ],
         output: [
-            { name: 'imported', type: 'number', required: true, constraint: 'Count of memory docs written (bundle INDEX.md, sidecar docs, and the catalog INDEX.md).' },
-            { name: 'wouldImport', type: 'number', required: true, constraint: 'Count of memory docs that would be written under --dry-run.' },
-            { name: 'skipped', type: 'number', required: true, constraint: 'Count of same-named bundle collisions skipped (first-sorted package wins).' },
-            { name: 'excluded', type: 'number', required: true, constraint: 'Count of dependency skill bundles excluded by exact package.json crtr.sync.deps.exclude selectors.' },
             { name: 'results', type: 'object[]', required: true, constraint: 'Each: {source,target,name,scope,status,reason?}; status is one of imported, would-import, skipped, excluded. `name` is the full canonical name the vendored doc answers at (`<namespace>/deps/<bundle>`), except on an excluded row, which names the `<package>@<version>:<skill>` selector. An excluded row is a dependency bundle rejected before its files enter the vendoring planner.' },
         ],
         outputKind: 'object',
@@ -498,11 +494,7 @@ export const sysSyncDepsLeaf = defineLeaf({
         const sourceArg = input['source'];
         const dryRun = input['dryRun'] ?? false;
         const results = runDepsSync({ sourceArg, dryRun });
-        const imported = results.filter((r) => r.status === 'imported').length;
-        const wouldImport = results.filter((r) => r.status === 'would-import').length;
-        const skipped = results.filter((r) => r.status === 'skipped').length;
-        const excluded = results.filter((r) => r.status === 'excluded').length;
-        return { imported, wouldImport, skipped, excluded, results };
+        return { results };
     },
     render: (result) => renderDepsSummary(result.results),
 });

package/dist/commands/sys/sync-project-guidance.js

@@ -379,9 +379,6 @@ export const sysSyncProjectGuidanceLeaf = defineLeaf({
             { kind: 'flag', name: 'overwrite', type: 'bool', required: false, constraint: 'Replace an existing target memory doc. Default: skip existing docs to avoid clobbering user-authored memory.' },
         ],
         output: [
-            { name: 'imported', type: 'number', required: true, constraint: 'Count of memory docs written.' },
-            { name: 'wouldImport', type: 'number', required: true, constraint: 'Count of memory docs that would be written under --dry-run.' },
-            { name: 'skipped', type: 'number', required: true, constraint: 'Count of source files skipped (existing target without --overwrite).' },
             { name: 'results', type: 'object[]', required: true, constraint: 'Each: {source,target,name,scope,status,reason?}; status is one of imported, skipped, would-import.' },
         ],
         outputKind: 'object',
@@ -477,10 +474,7 @@ export const sysSyncProjectGuidanceLeaf = defineLeaf({
         for (const { prepared } of ordered) {
             results.push(convertProjectDoc(prepared, { dryRun, overwrite }));
         }
-        const imported = results.filter((r) => r.status === 'imported').length;
-        const wouldImport = results.filter((r) => r.status === 'would-import').length;
-        const skipped = results.filter((r) => r.status === 'skipped').length;
-        return { imported, wouldImport, skipped, results };
+        return { results };
     },
     render: (result) => renderSummary(result.results),
 });

package/dist/commands/sys/sync-skills.js

@@ -250,11 +250,6 @@ export const sysSyncSkillsLeaf = defineLeaf({
             { kind: 'flag', name: 'include-ignored', type: 'bool', required: false, constraint: 'Include ignored candidates in the report without making sync read-only. Pair with --dry-run to audit the full candidate set without importing non-ignored skills.' },
         ],
         output: [
-            { name: 'imported', type: 'number', required: true, constraint: 'Count of memory docs written.' },
-            { name: 'wouldImport', type: 'number', required: true, constraint: 'Count of memory docs that would be written under --dry-run.' },
-            { name: 'skipped', type: 'number', required: true, constraint: 'Count of source files skipped (existing target without --overwrite, or an unimportable SKILL.md).' },
-            { name: 'ignored', type: 'number', required: true, constraint: 'Count of selected SKILL.md files that are permanently ignored.' },
-            { name: 'wouldIgnore', type: 'number', required: true, constraint: 'Count of selected SKILL.md files that would be ignored under --dry-run.' },
             { name: 'results', type: 'object[]', required: true, constraint: 'Each: {source,target,name,scope,status,reason?}; status is one of imported, skipped, would-import, ignored, would-ignore. `name` is the full canonical name the imported doc answers at — a user import’s bundle name, a project import’s `<namespace>/<bundle name>`.' },
         ],
         outputKind: 'object',
@@ -310,12 +305,7 @@ export const sysSyncSkillsLeaf = defineLeaf({
         }
         if (changedIgnoreState)
             writeIgnoreState(ignoreState);
-        const imported = results.filter((r) => r.status === 'imported').length;
-        const wouldImport = results.filter((r) => r.status === 'would-import').length;
-        const skipped = results.filter((r) => r.status === 'skipped').length;
-        const ignored = results.filter((r) => r.status === 'ignored').length;
-        const wouldIgnore = results.filter((r) => r.status === 'would-ignore').length;
-        return { imported, wouldImport, skipped, ignored, wouldIgnore, results, ignoreFile: ignoreFilePath(), ignoreMode };
+        return { results, ignoreFile: ignoreFilePath(), ignoreMode };
     },
     render: (result) => renderSummary(result.results, result.ignoreMode === true),
 });

package/dist/core/__tests__/cron-node-sink-parked-root.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/cron-node-sink-parked-root.test.js

@@ -0,0 +1,147 @@
+// Run with: npm test -- --test-name-pattern='cron node sink'
+//
+// A resident root parked by the unattended clock is status=done without a
+// final-report latch. Its anchored cron is the explicit next cycle that must
+// append durably and resume the existing session; finalized and canceled rows
+// remain ordinary undeliverable node sinks.
+import { after, afterEach, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode, getNode, listNodes } from '../canvas/canvas.js';
+import { armCron, getCron } from '../canvas/crons.js';
+import { closeDb } from '../canvas/db.js';
+import { readInboxSince } from '../feed/inbox.js';
+import { headlessBrokerHost } from '../runtime/host.js';
+import { resetFleetForTests } from '../runtime/fleet.js';
+import { applyParkEvent, parkEvent } from '../../daemon/reconcilers/live-obligation.js';
+import { executeCron } from '../../daemon/cron-run.js';
+import { bindTestFleet } from './helpers/fleet.js';
+let home;
+let priorHome;
+let fleet;
+let launches;
+let originalLaunch;
+function node(id, over = {}) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'resident',
+        status: 'active',
+        ...over,
+    };
+}
+function arm({ cron_id, ...overrides }) {
+    armCron({
+        cron_id,
+        name: cron_id,
+        created_by: null,
+        command: "printf 'cron output'",
+        fire_at: new Date(Date.now() - 1_000).toISOString(),
+        recur: JSON.stringify({ every: '1h' }),
+        tz: null,
+        expires_at: null,
+        anchor_node: null,
+        cancel_on_wake: false,
+        cwd: home,
+        env_json: null,
+        profile: null,
+        scope: 'profile',
+        run_timeout_s: 30,
+        overlap: 'skip',
+        on_output: 'always',
+        sink: '{}',
+        tier: 'normal',
+        ...overrides,
+    });
+}
+/** Produce the exact unattended resident-root shape: `park` writes done with
+ * the park marker and leaves the final-report latch empty. A real 15-minute
+ * clock reaches this same transition, through a summary turn on the good path
+ * and directly on the degraded one. */
+function parkResidentRoot(id) {
+    const sessionFile = join(home, `${id}.jsonl`);
+    writeFileSync(sessionFile, '{}\n');
+    createNode(node(id, { pi_session_id: `${id}-session`, pi_session_file: sessionFile }));
+    const event = parkEvent(id, 'resident');
+    assert.equal(event, 'park');
+    applyParkEvent(id, event);
+    const parked = getNode(id);
+    assert.equal(parked.status, 'done');
+    assert.equal(parked.intent, 'parked');
+    assert.equal(parked.final_report ?? null, null);
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-cron-node-sink-parked-root-'));
+    priorHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    mkdirSync(home, { recursive: true });
+    resetFleetForTests();
+    fleet = bindTestFleet();
+    launches = [];
+    originalLaunch = headlessBrokerHost.launch;
+    headlessBrokerHost.launch = ((nodeId, _inv, opts) => {
+        launches.push({ nodeId, resuming: opts.resuming });
+        const handle = { pid: 0x7ffffffe, exited: new Promise(() => { }) };
+        fleet.fleet.register(nodeId, handle);
+        return handle;
+    });
+});
+afterEach(() => {
+    headlessBrokerHost.launch = originalLaunch;
+    closeDb();
+    resetFleetForTests();
+});
+after(() => {
+    rmSync(home, { recursive: true, force: true });
+    if (priorHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = priorHome;
+});
+test('cron node sink delivers to a parked resident root and resumes its existing session without escalation', async () => {
+    parkResidentRoot('parked-root');
+    arm({ cron_id: 'parked-root-cron', sink: JSON.stringify({ node: 'parked-root' }), anchor_node: 'parked-root' });
+    const record = await executeCron(getCron('parked-root-cron'), { outOfBand: false });
+    assert.equal(record?.delivered, 'delivered: node parked-root');
+    assert.equal(getCron('parked-root-cron').state, 'active', 'delivery does not pause the cron');
+    assert.deepEqual(readInboxSince('parked-root', undefined).map((entry) => entry.data?.['body']), ['cron output']);
+    assert.deepEqual(launches, [{ nodeId: 'parked-root', resuming: true }], 'the parked session is resumed exactly once');
+    assert.equal(getNode('parked-root').status, 'active', 'revive restores the parked root to its active cycle');
+    assert.deepEqual(listNodes().map((entry) => entry.node_id), ['parked-root'], 'no escalation node was created');
+});
+test('finalized and canceled node-sink targets still pause and escalate without delivery', async () => {
+    const targets = [
+        ['finalized-root', { status: 'done', final_report: 'final.md', finalized_at: new Date().toISOString() }],
+        ['canceled-root', { status: 'canceled' }],
+    ];
+    for (const [id, state] of targets) {
+        createNode(node(id, state));
+        arm({ cron_id: `${id}-cron`, sink: JSON.stringify({ node: id }) });
+        const before = listNodes().length;
+        const record = await executeCron(getCron(`${id}-cron`), { outOfBand: false });
+        assert.match(record?.delivered ?? '', /^failure: cron paused, escalation node /, `${id}: failure is escalated`);
+        assert.equal(getCron(`${id}-cron`).state, 'paused', `${id}: cron is paused`);
+        assert.equal(readInboxSince(id, undefined).length, 0, `${id}: no message was appended`);
+        assert.equal(listNodes().length, before + 1, `${id}: exactly one escalation node was created`);
+    }
+});
+test('a deferred node-sink entry reaches the parked root durably but never revives it', async () => {
+    parkResidentRoot('deferred-root');
+    arm({ cron_id: 'deferred-root-cron', sink: JSON.stringify({ node: 'deferred-root' }), tier: 'deferred' });
+    const record = await executeCron(getCron('deferred-root-cron'), { outOfBand: false });
+    assert.equal(record?.delivered, 'delivered: node deferred-root');
+    assert.equal(getCron('deferred-root-cron').state, 'active');
+    assert.deepEqual(readInboxSince('deferred-root', undefined).map((entry) => entry.tier), ['deferred']);
+    assert.deepEqual(launches, [], 'deferred delivery never launches a dormant target');
+    assert.equal(getNode('deferred-root').status, 'done', 'the parked target remains parked');
+});

package/dist/core/__tests__/history-inbox.test.js

@@ -13,7 +13,7 @@ import { createNode } from '../canvas/canvas.js';
 import { closeDb } from '../canvas/db.js';
 import { contextDir } from '../canvas/paths.js';
 import { appendInbox } from '../feed/inbox.js';
-import { buildCorpus, resolveRef } from '../canvas/history.js';
+import { buildCorpus, nodeArtifacts, resolveRef } from '../canvas/history.js';
 let home;
 function node(id, cwd) {
     return {
@@ -49,6 +49,16 @@ test('history corpus skips malformed frontmatter in another cwd', () => {
     assert.equal(corpus.some((a) => a.ref === `${broken.node_id}:context/copied-source.md`), false, 'invalid artifact is skipped');
     assert.ok(corpus.some((a) => a.loadBody().includes('0a0afd613')), 'valid artifacts remain searchable');
 });
+test('one node\'s artifact listing skips malformed frontmatter instead of failing', () => {
+    const n = createNode(node('single-node-broken', '/tmp/hist-single'));
+    // A context dir often holds foreign markdown (a checked-out repo) whose
+    // `---` header is not crouter frontmatter.
+    writeFileSync(join(contextDir(n.node_id), 'copied-source.md'), '---\npattern: "@(IsString)\\("\n---\nsource text\n');
+    writeFileSync(join(contextDir(n.node_id), 'result.md'), '---\ntitle: result\n---\n0a0afd613\n');
+    const arts = nodeArtifacts(n.node_id);
+    assert.equal(arts.some((a) => a.relpath === 'context/copied-source.md'), false, 'invalid artifact is skipped');
+    assert.ok(arts.some((a) => a.relpath === 'context/result.md'), 'valid artifacts still listed');
+});
 test('default history excludes inbox; --type inbox includes it, with full sender-attributed bodies', () => {
     const cwd = '/tmp/hist-work';
     createNode(node('sender-1', cwd));

package/dist/core/__tests__/human-deliver.test.js

@@ -9,7 +9,8 @@ import { join } from 'node:path';
 import { ApiError } from '../../api/index.js';
 import { createApiServer } from '../../daemon/api/server.js';
 import { cancelHumanTicket, deliverTerminalResult, resolvePageTicket, settleFeedbackCompanion } from '../../daemon/human/finish.js';
-import { humanSend } from '../../commands/human/prompts.js';
+import { humanSend as buildHumanSend } from '../../commands/human/prompts.js';
+const humanSend = buildHumanSend();
 import { getNode, listNodes, closeDb } from '../canvas/index.js';
 import { coalesce, readInboxSince } from '../feed/inbox.js';
 import { createPageFeedbackComment } from '../human/feedback.js';

package/dist/core/__tests__/integration/command-plugins.test.js

@@ -739,7 +739,6 @@ describe('memory corpus gate across the plugin lifecycle', () => {
         // The package gains an old-format document while it sits disabled.
         writeDoc(join(source, 'memory', 'guide', 'INDEX.md'), 'kind: knowledge\nname: guide/INDEX', 'Guide.');
         const enabled = await pluginEnable.run({ name: 'lifecycle' });
-        assert.equal(enabled['enabled'], true);
         const memory = enabled['memory'];
         assert.deepEqual(memory.migrated, ['guide/INDEX.md']);
         assert.equal(memory.linkedSource, realpathSync(join(source, 'memory')));

package/dist/core/__tests__/integration/deferred-no-wake.test.js

@@ -160,7 +160,6 @@ test('node message send --tier deferred to an ordinary dormant (idle-released) t
     });
     try {
         const res = (await messageSendLeaf().run({ to: id, tier: 'deferred', body: 'a held note' }));
-        assert.equal(res['delivered'], true, 'the message is still delivered (appended), just not woken');
         assert.equal(res['revived'], false, 'deferred never revives a dormant target');
         assert.equal(res['guidance'], "Delivered — held for the target's next natural cycle; not revived.", 'guidance is truthful about the hold, not a claimed revive');
     }

package/dist/core/__tests__/lifecycle.test.js

@@ -12,7 +12,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode, setStatus, setIntent } from '../canvas/canvas.js';
 import { closeDb } from '../canvas/db.js';
-import { transition } from '../runtime/lifecycle.js';
+import { isParked, transition } from '../runtime/lifecycle.js';
 let home;
 function node(id) {
     return {
@@ -67,6 +67,34 @@ test('finalize: illegal from done|dead|canceled → throws, status untouched', (
     }
 });
 // ---------------------------------------------------------------------------
+// park → done + intent='parked', legal only from active|idle. The intent IS the
+// durable park marker: it must land atomically with the `done` it qualifies,
+// read only through isParked, and be cleared by revival.
+// ---------------------------------------------------------------------------
+test('park: active|idle → done + intent=parked, and isParked reads exactly that pair', () => {
+    for (const from of LIVE) {
+        mk(`n_${from}`, from);
+        const m = transition(`n_${from}`, 'park');
+        assert.equal(m.status, 'done', `park from ${from}`);
+        assert.equal(m.intent, 'parked', `park from ${from} sets intent=parked`);
+        assert.equal(isParked(m), true, `park from ${from} is readable as parked`);
+        assert.equal(m.final_report ?? null, null, `park from ${from} leaves the finalization latch unset`);
+    }
+});
+test('park: illegal from done|dead|canceled → throws', () => {
+    for (const from of TERMINAL) {
+        mk(`n_${from}`, from);
+        assert.throws(() => transition(`n_${from}`, 'park'), /illegal lifecycle transition/);
+    }
+});
+test('park: revival clears the marker, and no other done is parked', () => {
+    mk('reopened', 'active');
+    transition('reopened', 'park');
+    assert.equal(isParked(transition('reopened', 'revive')), false, 'revive clears intent=parked');
+    mk('finished', 'active');
+    assert.equal(isParked(transition('finished', 'finish')), false, 'a finished done is not a park');
+});
+// ---------------------------------------------------------------------------
 // cancel → canceled + intent cleared, legal from ANY status (forced teardown).
 // A5 (human-confirmed 2026-06-06): the `reap` event was COLLAPSED into `cancel`
 // — they were identical (status differed only; both intent=null, from=ANY, no
@@ -159,7 +187,7 @@ test('revive: any status → active + intent cleared', () => {
 // unknown node → throws for every event
 // ---------------------------------------------------------------------------
 test('transition on an unknown node throws', () => {
-    for (const ev of ['finish', 'cancel', 'crash', 'yield', 'release', 'refresh-launch', 'revive']) {
+    for (const ev of ['finish', 'park', 'cancel', 'crash', 'yield', 'release', 'refresh-launch', 'revive']) {
         assert.throws(() => transition('ghost', ev), /unknown node/);
     }
 });

package/dist/core/__tests__/revive-parked-fresh.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/revive-parked-fresh.test.js

@@ -0,0 +1,109 @@
+// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/revive-parked-fresh.test.ts
+//
+// Re-entering a parked node starts a FRESH cycle grounded in goal + roadmap
+// rather than replaying the transcript its parking turn already concluded. The
+// rule is a property of the node, evaluated once inside reviveNode, so every
+// doorway gets it from one strict-resume veto. Its one exception is a park with
+// nothing on disk to stand on (reachable only on the degraded path, which
+// writes no summary): resuming an old transcript beats waking amnesiac.
+import { after, afterEach, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode, getNode } from '../canvas/canvas.js';
+import { contextDir } from '../canvas/paths.js';
+import { closeDb } from '../canvas/db.js';
+import { transition } from '../runtime/lifecycle.js';
+import { reviveNode } from '../runtime/revive.js';
+import { headlessBrokerHost } from '../runtime/host.js';
+import { resetFleetForTests } from '../runtime/fleet.js';
+import { bindTestFleet } from './helpers/fleet.js';
+let home;
+let priorHome;
+let fleet;
+let launches;
+let originalLaunch;
+/** A parked resident with a real `.jsonl` on disk, so the choice between
+ *  resuming that transcript and cycling it is genuinely open. */
+function parkResident(id, ground = {}) {
+    const sessionFile = join(home, `${id}.jsonl`);
+    writeFileSync(sessionFile, '{}\n');
+    const meta = {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'resident',
+        status: 'active',
+        pi_session_id: `${id}-session`,
+        pi_session_file: sessionFile,
+    };
+    createNode(meta);
+    mkdirSync(contextDir(id), { recursive: true });
+    if (ground.roadmap !== undefined)
+        writeFileSync(join(contextDir(id), 'roadmap.md'), ground.roadmap);
+    if (ground.goal !== undefined)
+        writeFileSync(join(contextDir(id), 'initial-prompt.md'), ground.goal);
+    transition(id, 'park');
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-revive-parked-'));
+    priorHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    mkdirSync(home, { recursive: true });
+    resetFleetForTests();
+    fleet = bindTestFleet();
+    launches = [];
+    originalLaunch = headlessBrokerHost.launch;
+    headlessBrokerHost.launch = ((nodeId, _inv, opts) => {
+        launches.push({ nodeId, resuming: opts.resuming });
+        const handle = { pid: 0x7ffffffe, exited: new Promise(() => { }) };
+        fleet.fleet.register(nodeId, handle);
+        return handle;
+    });
+});
+afterEach(() => {
+    headlessBrokerHost.launch = originalLaunch;
+    closeDb();
+    resetFleetForTests();
+});
+after(() => {
+    rmSync(home, { recursive: true, force: true });
+    if (priorHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = priorHome;
+});
+test('a parked node with a roadmap re-enters fresh even when the caller asked to resume, and the marker clears', () => {
+    parkResident('parked', { roadmap: '# Roadmap\n\n- one open item\n' });
+    const result = reviveNode('parked', { resume: true });
+    assert.equal(result.resumed, false, 'the concluded transcript is not replayed');
+    assert.deepEqual(launches, [{ nodeId: 'parked', resuming: false }]);
+    const reopened = getNode('parked');
+    assert.equal(reopened.status, 'active');
+    assert.equal(reopened.intent ?? null, null, 'the park marker clears on revival');
+    assert.equal(reopened.cycle_pending, true, 'the fresh cycle is provisional until session_start confirms it');
+});
+test('a parked node grounded only by a goal still re-enters fresh', () => {
+    parkResident('goal-only', { goal: 'Watch the deploy lane.' });
+    assert.equal(reviveNode('goal-only', { resume: true }).resumed, false);
+});
+test('a parked node with no goal and no roadmap resumes its transcript rather than waking amnesiac', () => {
+    parkResident('bare');
+    const result = reviveNode('bare', { resume: true });
+    assert.equal(result.resumed, true, 'the degraded park has nothing on disk to ground a fresh window');
+    assert.deepEqual(launches, [{ nodeId: 'bare', resuming: true }]);
+});
+test('an ordinary done node with a roadmap still resumes — only the park marker vetoes', () => {
+    parkResident('finished', { roadmap: '# Roadmap\n\n- one open item\n' });
+    transition('finished', 'revive');
+    transition('finished', 'finish');
+    assert.equal(reviveNode('finished', { resume: true }).resumed, true);
+});