@north-light/crouter 0.3.173 → 0.3.174

package/dist/commands/__tests__/human.test.js

@@ -1,31 +1,16 @@
-// Tests for the human subtree argv-model migration.
-// Run with: node --import tsx/esm --test 'src/commands/__tests__/human.test.ts'
+// Regression: a caller passing BOTH a positional AND piped stdin (e.g.
+// `crtr node new --kind x "title" < prompt.md`, or `crtr human ask -
+// <<EOF`) used to have the positional silently win, with the entire piped
+// body dropped on the floor. `-` must always mean "read stdin", and any
+// OTHER positional alongside genuinely piped, non-empty stdin must error
+// loudly rather than silently pick one.
 //
-// These tests exercise the leaf param schemas via parseArgv (framework) and
-// spot-check the leaf definitions directly — no subprocess spawning, no tmux.
-import { test, describe, beforeEach, afterEach } from 'node:test';
+// Run with: node --import tsx/esm --test 'src/commands/__tests__/human.test.ts'
+import { test, describe } from 'node:test';
 import assert from 'node:assert/strict';
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { randomBytes } from 'node:crypto';
 import { Readable } from 'node:stream';
-import { parseArgv, unknownPathError } from '../../core/command.js';
-import { renderLeafArgv } from '../../core/help.js';
-import { humanAsk, sourceStamp } from '../human/prompts.js';
-import { humanReviewBranch } from '../human/review.js';
-import { registerHuman } from '../human.js';
-import { coerceSingleSelectAgainst } from '../human/queue.js';
-// ---------------------------------------------------------------------------
-// Helper: write a temp JSON file and return its path.
-// ---------------------------------------------------------------------------
-function tmpJson(obj) {
-    const dir = join(tmpdir(), `crtr-human-test-${randomBytes(4).toString('hex')}`);
-    mkdirSync(dir, { recursive: true });
-    const p = join(dir, 'deck.json');
-    writeFileSync(p, JSON.stringify(obj));
-    return p;
-}
+import { parseArgv } from '../../core/command.js';
+import { humanAsk } from '../human/prompts.js';
 async function withPipedStdin(body, fn) {
     const original = process.stdin;
     const stdin = Readable.from([Buffer.from(body)]);
@@ -38,178 +23,7 @@ async function withPipedStdin(body, fn) {
         Object.defineProperty(process, 'stdin', { value: original, configurable: true });
     }
 }
-// ---------------------------------------------------------------------------
-// human review new — positional file (path) + required --subtitle + optional --output
-// ---------------------------------------------------------------------------
-describe('human review command branch', () => {
-    const review = registerHuman().children.find((child) => child.name === 'review');
-    const newLeaf = humanReviewBranch.children.find((child) => child.name === 'new' && child.kind === 'leaf');
-    test('registers the canonical review branch', () => {
-        assert.equal(review, humanReviewBranch);
-        assert.deepEqual(humanReviewBranch.children.map((child) => child.name), ['new', 'comment']);
-    });
-    test('bare review names valid children rather than accepting the legacy file positional', () => {
-        const error = unknownPathError(humanReviewBranch, ['human', 'review'], '/tmp/plan.md');
-        assert.equal(error.code, 'unknown_path');
-        assert.match(error.message, /unknown subcommand: \/tmp\/plan\.md/);
-        assert.match(String(error.details?.next), /Valid children: new, comment/);
-    });
-    test('new parses file + required subtitle', async () => {
-        assert.ok(newLeaf);
-        const result = await parseArgv(newLeaf.help.params ?? [], ['/tmp/plan.md', '--subtitle', 'Review this plan so implementation can begin safely.']);
-        assert.equal(result['file'], '/tmp/plan.md');
-        assert.equal(result['subtitle'], 'Review this plan so implementation can begin safely.');
-    });
-    test('new parses file + subtitle + --output', async () => {
-        assert.ok(newLeaf);
-        const result = await parseArgv(newLeaf.help.params ?? [], ['/tmp/plan.md', '--subtitle', 'Review this plan so implementation can begin safely.', '--output', '/tmp/fb.json']);
-        assert.equal(result['file'], '/tmp/plan.md');
-        assert.equal(result['output'], '/tmp/fb.json');
-    });
-    // Validation is complete, never first-failure: one invocation yields ONE
-    // error naming every missing required parameter, and its Next: mandates the
-    // schema read rather than patching the first field.
-    test('new missing file AND subtitle throws ONE missing_parameter naming both', async () => {
-        assert.ok(newLeaf);
-        await assert.rejects(() => parseArgv(newLeaf.help.params ?? [], [], { leafPath: ['human', 'review', 'new'] }), (err) => {
-            assert.match(err.message, /required parameters are missing: positional FILE, --subtitle/);
-            assert.equal(err.details?.field, 'file, subtitle');
-            assert.match(err.details?.next ?? '', /Run `crtr human review new -h` and read the full schema before re-issuing/);
-            return true;
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// human notify — positional title + required --subtitle + optional --body
-// ---------------------------------------------------------------------------
-describe('human notify: params', () => {
-    const params = [
-        { kind: 'positional', name: 'title', type: 'string', required: true, constraint: 'Headline.' },
-        { kind: 'flag', name: 'subtitle', type: 'string', required: true, constraint: 'Status and stakes.' },
-        { kind: 'flag', name: 'body', type: 'string', required: false, constraint: 'Markdown body.' },
-    ];
-    test('parses positional title + required subtitle', async () => {
-        const result = await parseArgv(params, ['Build done', '--subtitle', 'The build passed, so the change is ready to review.']);
-        assert.equal(result['title'], 'Build done');
-        assert.equal(result['subtitle'], 'The build passed, so the change is ready to review.');
-    });
-    test('parses title + subtitle + --body', async () => {
-        const result = await parseArgv(params, ['Done', '--subtitle', 'All tests passed, so deployment can proceed.', '--body', 'All tests pass.']);
-        assert.equal(result['title'], 'Done');
-        assert.equal(result['body'], 'All tests pass.');
-    });
-});
-// ---------------------------------------------------------------------------
-// human show — positional path + --watch bool + --window enum
-// ---------------------------------------------------------------------------
-describe('human show: params', () => {
-    const params = [
-        { kind: 'positional', name: 'path', type: 'path', required: true, constraint: 'File to render.' },
-        { kind: 'flag', name: 'watch', type: 'bool', required: false, constraint: 'Presence = true.' },
-        { kind: 'flag', name: 'window', type: 'enum', choices: ['auto', 'split', 'new'], required: false, default: 'auto', constraint: 'Placement.' },
-    ];
-    test('parses positional path', async () => {
-        const result = await parseArgv(params, ['/tmp/doc.md']);
-        assert.equal(result['path'], '/tmp/doc.md');
-    });
-    test('--watch absent → false (presence-only bool default)', async () => {
-        const result = await parseArgv(params, ['/tmp/doc.md']);
-        assert.equal(result['watch'], false);
-    });
-    test('--watch present → true', async () => {
-        const result = await parseArgv(params, ['/tmp/doc.md', '--watch']);
-        assert.equal(result['watch'], true);
-    });
-    test('--watch=true is rejected (bool takes no value)', async () => {
-        await assert.rejects(() => parseArgv(params, ['/tmp/doc.md', '--watch=true']), (err) => { assert.match(err.message, /takes no value/); return true; });
-    });
-    test('--window default is auto', async () => {
-        const result = await parseArgv(params, ['/tmp/doc.md']);
-        assert.equal(result['window'], 'auto');
-    });
-    test('--window accepts valid enum value', async () => {
-        const result = await parseArgv(params, ['/tmp/doc.md', '--window', 'split']);
-        assert.equal(result['window'], 'split');
-    });
-    test('--window rejects invalid value', async () => {
-        await assert.rejects(() => parseArgv(params, ['/tmp/doc.md', '--window', 'float']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// human ask — --context-file (context-file kind, key=deckFile)
-//
-// NOTE: The argv parser hardcodes the CLI token as `--context-file` regardless
-// of the param's `name` field. The `name` field ("deckFile") becomes the key
-// in the input record. So the correct invocation is:
-//   crtr human ask --context-file deck.json
-// not --deck-file. Tests use --context-file accordingly.
-// ---------------------------------------------------------------------------
-describe('human ask: params', () => {
-    const params = [
-        { kind: 'context-file', name: 'deckFile', required: true, constraint: 'Humanloop deck JSON.' },
-    ];
-    test('--context-file parses JSON file and yields input.deckFile', async () => {
-        const deck = { interactions: [{ id: 'q', title: 'Go?', subtitle: 'Approve going ahead so the work can continue.', options: [{ id: 'yes', label: 'Yes' }] }] };
-        const path = tmpJson(deck);
-        const result = await parseArgv(params, ['--context-file', path]);
-        assert.deepEqual(result['deckFile'], deck);
-    });
-    test('--context-file missing → missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('--context-file with nonexistent file → invalid_type', async () => {
-        await assert.rejects(() => parseArgv(params, ['--context-file', '/no/such/deck.json']), (err) => { assert.match(err.message, /cannot read file/); return true; });
-    });
-    test('--context-file with non-JSON file → invalid_type', async () => {
-        const dir = join(tmpdir(), `crtr-human-test-${randomBytes(4).toString('hex')}`);
-        mkdirSync(dir, { recursive: true });
-        const p = join(dir, 'bad.json');
-        writeFileSync(p, 'not json at all');
-        await assert.rejects(() => parseArgv(params, ['--context-file', p]), (err) => { assert.match(err.message, /not valid JSON/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// human ask — stdin question + strict --context-file deck
-// ---------------------------------------------------------------------------
-describe('human ask: stdin question + strict deck', () => {
-    test('help requires an explicit title with the literal stdin body', () => {
-        const out = renderLeafArgv(humanAsk.help);
-        assert.match(out, /^  --title TITLE\s+string, optional\. Required with stdin:/m);
-        assert.match(out, /^  --subtitle SUBTITLE\s+string, optional\. Required with stdin:/m);
-        assert.match(out, /^  stdin\s+optional\. Simple open-text ask body\./m);
-        assert.match(out, /single-quoted heredoc/);
-        assert.match(out, /--context-file PATH/);
-        assert.match(out, /bodyPath is a relative path to the body file, resolved from the directory containing the deck JSON/);
-        assert.match(out, /paths escaping with \.\. or symlinks are rejected; absolute paths are unsupported/);
-        assert.doesNotMatch(out, /crtr human ask "<question>"/);
-    });
-    test('reads an explicit title and literal question bytes', async () => {
-        const question = 'Literal `backticks`, $dollars, $(command), ; semicolon, * glob\nsecond line\n';
-        const result = await withPipedStdin(question, () => parseArgv(humanAsk.help.params ?? [], ['--title', 'Release decision', '--subtitle', 'Choose whether to release now so the launch can proceed.']));
-        assert.equal(result['title'], 'Release decision');
-        assert.equal(result['subtitle'], 'Choose whether to release now so the launch can proceed.');
-        assert.equal(result['question'], question);
-    });
-    test('required stdin errors prescribe stdin rather than a positional payload', async () => {
-        const params = [{ kind: 'stdin', name: 'body', required: true, constraint: 'Markdown.' }];
-        await assert.rejects(() => withPipedStdin('', () => parseArgv(params, [])), (err) => {
-            assert.match(err.message, /required parameter is missing: stdin/);
-            assert.equal(err.details?.field, 'body');
-            assert.match(err.details?.next ?? '', /read the full schema before re-issuing/);
-            assert.doesNotMatch(err.details?.next ?? '', /positional argument/);
-            return true;
-        });
-    });
-    test('retains positional input compatibility without advertising it to agents', async () => {
-        const result = await parseArgv(humanAsk.help.params ?? [], ['Should we ship today?']);
-        assert.equal(result['question'], 'Should we ship today?');
-    });
-    // Regression: a caller passing BOTH a positional AND piped stdin (e.g.
-    // `crtr node new --kind x "title" < prompt.md`, or `crtr human ask -
-    // <<EOF`) used to have the positional silently win, with the entire piped
-    // body dropped on the floor. `-` must always mean "read stdin", and any
-    // OTHER positional alongside genuinely piped, non-empty stdin must error
-    // loudly rather than silently pick one.
+describe('human ask: positional vs piped stdin', () => {
     test('`-` positional reads stdin instead of taking the literal value', async () => {
         const body = 'Should we ship today?\nmulti-line brief\n';
         const result = await withPipedStdin(body, () => parseArgv(humanAsk.help.params ?? [], ['-']));
@@ -230,129 +44,4 @@ describe('human ask: stdin question + strict deck', () => {
         const result = await withPipedStdin('', () => parseArgv(humanAsk.help.params ?? [], ['Should we ship today?']));
         assert.equal(result['question'], 'Should we ship today?');
     });
-    test('parses --context-file into input.deck while keeping the strict deck path', async () => {
-        const deck = {
-            title: 'Choose a path',
-            interactions: [
-                { id: 'q', title: 'Pick one', subtitle: 'Choose the path that best supports the release.', options: [{ id: 'yes', label: 'Yes' }] },
-            ],
-        };
-        const path = tmpJson(deck);
-        const result = await withPipedStdin('', () => parseArgv(humanAsk.help.params ?? [], ['--context-file', path]));
-        assert.deepEqual(result['deck'], deck);
-    });
-});
-// ---------------------------------------------------------------------------
-// human cancel — positional job_id + optional --reason
-// ---------------------------------------------------------------------------
-describe('human cancel: params', () => {
-    const params = [
-        { kind: 'positional', name: 'job_id', type: 'string', required: true, constraint: 'Interaction node id.' },
-        { kind: 'flag', name: 'reason', type: 'string', required: false, constraint: 'Why it was retracted.' },
-    ];
-    test('parses positional job_id', async () => {
-        const result = await parseArgv(params, ['abc-1234']);
-        assert.equal(result['job_id'], 'abc-1234');
-    });
-    test('parses job_id + --reason', async () => {
-        const result = await parseArgv(params, ['abc-1234', '--reason', 'answered myself']);
-        assert.equal(result['job_id'], 'abc-1234');
-        assert.equal(result['reason'], 'answered myself');
-    });
-    test('missing job_id throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// sourceStamp — an optional presentation label, nothing more.
-//
-// Ticket identity and attribution come from the bridge node directory and its
-// parent relation, never from deck data — so the stamp carries at most
-// `{sessionName}`, resolved from CRTR_NODE_ID through crtrd. Without a node id,
-// or when crtrd cannot resolve one, the stamp is empty. `human cancel` is not
-// unit-testable in-process for the same reason: it delegates node lookup +
-// cancellation to crtrd, so exercising it needs a live daemon.
-// ---------------------------------------------------------------------------
-describe('sourceStamp: asking-node attribution', () => {
-    beforeEach(() => {
-        delete process.env['CRTR_NODE_ID'];
-    });
-    afterEach(() => {
-        delete process.env['CRTR_NODE_ID'];
-    });
-    test('bare shell (no CRTR_NODE_ID) → empty stamp', async () => {
-        assert.deepEqual(await sourceStamp(), {});
-    });
-    test('CRTR_NODE_ID crtrd cannot resolve → empty stamp, never a raw node id', async () => {
-        process.env['CRTR_NODE_ID'] = 'ghost-node';
-        assert.deepEqual(await sourceStamp(), {});
-    });
-});
-// ---------------------------------------------------------------------------
-// human list — --limit int + --cursor string
-// ---------------------------------------------------------------------------
-describe('human list: params', () => {
-    const params = [
-        { kind: 'flag', name: 'limit', type: 'int', required: false, default: 20, constraint: 'Default 20.' },
-        { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: 'Pagination token.' },
-    ];
-    test('defaults: limit=20, cursor=undefined', async () => {
-        const result = await parseArgv(params, []);
-        assert.equal(result['limit'], 20);
-        assert.equal(result['cursor'], undefined);
-    });
-    test('--limit parses integer', async () => {
-        const result = await parseArgv(params, ['--limit', '5']);
-        assert.equal(result['limit'], 5);
-    });
-    test('--limit rejects non-integer', async () => {
-        await assert.rejects(() => parseArgv(params, ['--limit', 'abc']), (err) => { assert.match(err.message, /must be an integer/); return true; });
-    });
-    test('--cursor passes through as string', async () => {
-        const result = await parseArgv(params, ['--cursor', 'tok_abc123']);
-        assert.equal(result['cursor'], 'tok_abc123');
-    });
-});
-// ---------------------------------------------------------------------------
-// human resolve — web-array → humanloop single-select coercion.
-//
-// Regression: the web always posts `selectedOptionIds` (an array) for every
-// option pick, but humanloop's strict validator rejects an array on a
-// non-multiSelect interaction ("invalid multi-select response"). Every
-// single-select deck resolved from the web — notify acks, yes/no approvals,
-// radio decisions — failed until this coercion. Multi-select and freetext must
-// pass through untouched.
-// ---------------------------------------------------------------------------
-describe('coerceSingleSelectAgainst: web array → humanloop shape', () => {
-    const deck = {
-        interactions: [
-            { id: 'notify', title: 'n', subtitle: 'Acknowledge this notice so the work can continue.', options: [{ id: 'ok', label: 'OK' }], kind: 'notify' },
-            { id: 'pick', title: 'p', subtitle: 'Choose every applicable option so the plan can continue.', options: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }], multiSelect: true },
-            { id: 'ask', title: 'a', subtitle: 'Provide guidance so the work can continue.', options: [], allowFreetext: true },
-        ],
-    };
-    test('single-select 1-element array folds to selectedOptionId', () => {
-        const [r] = coerceSingleSelectAgainst([{ id: 'notify', selectedOptionIds: ['ok'] }], deck);
-        assert.equal(r.selectedOptionId, 'ok');
-        assert.equal(r.selectedOptionIds, undefined);
-    });
-    test('multi-select array passes through untouched', () => {
-        const [r] = coerceSingleSelectAgainst([{ id: 'pick', selectedOptionIds: ['a', 'b'] }], deck);
-        assert.deepEqual(r.selectedOptionIds, ['a', 'b']);
-        assert.equal(r.selectedOptionId, undefined);
-    });
-    test('single-select multi-element array is left for humanloop to reject', () => {
-        const [r] = coerceSingleSelectAgainst([{ id: 'notify', selectedOptionIds: ['ok', 'x'] }], deck);
-        assert.deepEqual(r.selectedOptionIds, ['ok', 'x']);
-        assert.equal(r.selectedOptionId, undefined);
-    });
-    test('freetext response passes through untouched', () => {
-        const [r] = coerceSingleSelectAgainst([{ id: 'ask', freetext: 'hello' }], deck);
-        assert.equal(r.freetext, 'hello');
-        assert.equal(r.selectedOptionId, undefined);
-    });
-    test('already-singular response is preserved', () => {
-        const [r] = coerceSingleSelectAgainst([{ id: 'notify', selectedOptionId: 'ok' }], deck);
-        assert.equal(r.selectedOptionId, 'ok');
-    });
 });

package/dist/commands/api-client.d.ts

@@ -1,8 +1,8 @@
 import { CrtrClient } from '../api/index.js';
 import type { CanvasSource } from '../core/canvas/source.js';
-import type { NodeMeta, NodeRow, NodeStatus, SubscriptionRef } from '../core/canvas/types.js';
+import type { NodeStatus, SubscriptionRef } from '../core/canvas/types.js';
 import type { Scope } from '../types.js';
-import type { NodeDetailDTO } from '../api/dto/nodes.js';
+import type { NodeDetailDTO, NodeSummaryDTO } from '../api/dto/nodes.js';
 /** Rethrow an `ApiError` as the clean structured CLI error agents parse
  *  (`core/io` `handle`) — instead of the generic "internal bug" stderr path a
  *  raw non-`CrtrError` throw would take. The mapping itself lives in ONE place
@@ -65,11 +65,11 @@ export declare class ApiCanvasSource implements CanvasSource {
     /** Map a 404 from the API to the interface's `null` "not found" contract;
      *  re-throw everything else. */
     private orNull;
-    getNode(nodeId: string): Promise<NodeMeta | null>;
-    getRow(nodeId: string): Promise<NodeRow | null>;
+    getNode(nodeId: string): Promise<NodeDetailDTO | null>;
+    getRow(nodeId: string): Promise<NodeDetailDTO | null>;
     listNodes(filter?: {
         status?: NodeStatus | NodeStatus[];
-    }): Promise<NodeRow[]>;
+    }): Promise<NodeSummaryDTO[]>;
     subscriptionsOf(subscriber: string): Promise<SubscriptionRef[]>;
     subscribersOf(publisher: string): Promise<SubscriptionRef[]>;
     /** BFS over the active `subscribes_to` edges from `root` (its transitive view),

package/dist/commands/api-client.js

@@ -146,88 +146,11 @@ export function cliClient(opts) {
     });
 }
 // ---------------------------------------------------------------------------
-// DTO → internal projections
-//
-// The DTO boundary deliberately reshapes internals (spec §3.1), so these are
-// lossy in the read-only direction: fields the API surface does not carry
-// (tmux-presence runtime, per-edge `active`) are defaulted, matching the
-// documented parity bar (structural, not byte-identical). See the mapping notes
-// on each helper.
-// ---------------------------------------------------------------------------
-/** `NodeSummaryDTO` → `NodeRow`. The DTO carries every indexed identity + core
- *  runtime column; the four fields it omits are LOCAL tmux-presence /
- *  process-identity runtime (`window`/`tmux_session`/`pane`/`pi_pid_identity`),
- *  which are meaningless to a remote/pure client and are defaulted to null. A
- *  viewer reading canvas STRUCTURE never needs them; local placement reads them
- *  from tmux, not the source. */
-function summaryToRow(s) {
-    return {
-        node_id: s.node_id,
-        name: s.name,
-        kind: s.kind,
-        mode: s.mode,
-        lifecycle: s.lifecycle,
-        status: s.status,
-        cwd: s.cwd,
-        host_kind: s.host_kind,
-        profile_id: s.profile_id,
-        parent: s.parent,
-        created: s.created,
-        intent: s.intent,
-        waiting_for: s.waiting_for,
-        final_report: s.final_report ?? null,
-        finalized_at: s.finalized_at ?? null,
-        pi_pid: s.pi_pid,
-        pi_pid_identity: null,
-        window: null,
-        tmux_session: null,
-        pane: null,
-    };
-}
-/** `NodeDetailDTO` → `NodeMeta`. Populates the durable-identity ∪ runtime fields
- *  the DTO projects; the durable LAUNCH-RECIPE facts a projection cannot carry
- *  (`launch`/`env`, `persona_ack`, `model_override`, `passive_default`,
- *  `fork_from`, `pi_session_file`,
- *  `cycle_pending`) are left undefined — read-only viewer/inspect consumers
- *  (Stage B-7/B-9) never read them; the daemon owns the full meta for revive. */
-function detailToMeta(d) {
-    return {
-        node_id: d.node_id,
-        name: d.name,
-        description: d.description,
-        icon: d.icon,
-        cycles: d.cycles,
-        created: d.created,
-        cwd: d.cwd,
-        host_kind: d.host_kind,
-        profile_id: d.profile_id,
-        kind: d.kind,
-        mode: d.mode,
-        lifecycle: d.lifecycle,
-        parent: d.parent,
-        spawned_by: d.edges.spawned_by,
-        pi_session_id: d.pi_session_id ?? null,
-        managed_worktree: d.worktree ?? null,
-        // Runtime (from the authoritative row, projected onto the DTO).
-        status: d.status,
-        intent: d.intent,
-        waiting_for: d.waiting_for,
-        final_report: d.final_report ?? null,
-        finalized_at: d.finalized_at ?? null,
-        pi_pid: d.pi_pid,
-        pi_pid_identity: d.pi_pid_identity ?? null,
-    };
-}
-/** Edge ids → `SubscriptionRef[]`. KNOWN GAP: `NodeEdgesDTO` carries only the
- *  peer node ids, not the per-edge `active` flag or `created` timestamp (the
- *  `GET /nodes/{id}` projection built in A-1/A-7 does not expose them). We
- *  default `active: true` (the SAFE direction — never under-reports a live
- *  listener) and `created: ''` (matching `RemoteCanvasSource`'s same-shaped
- *  fallback). Fully faithful `active`/`created` needs an additive DTO extension
- *  (surface it as objects), which is an A-1/A-7 change, not B-0. */
-// ---------------------------------------------------------------------------
 // ApiCanvasSource — a read CanvasSource backed entirely by the crtrd API
 // ---------------------------------------------------------------------------
+// NodeSummaryDTO now carries every NodeRow field and NodeDetailDTO extends it,
+// so the viewer adapter returns the daemon's typed projections directly. It
+// performs no lossy legacy reconstruction or invented local-presence values.
 // The attach viewer's recurring subtree walk (chrome/canvas-panels.ts + overlays/graph.ts
 // computeActivity/visitActivity) calls subscriptionsOf/subscribersOf once per
 // visited node on every poll tick; each call was previously its own
@@ -279,12 +202,10 @@ export class ApiCanvasSource {
         }
     }
     async getNode(nodeId) {
-        const detail = await this.orNull(() => this.client.getNode(nodeId));
-        return detail ? detailToMeta(detail) : null;
+        return this.orNull(() => this.client.getNode(nodeId));
     }
     async getRow(nodeId) {
-        const detail = await this.orNull(() => this.client.getNode(nodeId));
-        return detail ? summaryToRow(detail) : null;
+        return this.orNull(() => this.client.getNode(nodeId));
     }
     async listNodes(filter) {
         const status = filter?.status;
@@ -302,7 +223,7 @@ export class ApiCanvasSource {
         else {
             rows = await this.client.listNodes();
         }
-        return rows.map(summaryToRow);
+        return rows;
     }
     async subscriptionsOf(subscriber) {
         const roster = await this.roster();

package/dist/commands/canvas-browse.js

@@ -7,10 +7,7 @@
 // Outside a TTY it prints the static forest and exits 0 (see runBrowse).
 import { defineLeaf } from '../core/command.js';
 import { runBrowse } from '../core/canvas/browse/app.js';
-import { cliClient, cliCanvasSource } from './api-client.js';
-import { resolveRemoteCanvasTarget } from '../core/remote-canvas-target.js';
-import { RemoteEventStream } from '../core/canvas/remote-event-stream.js';
-import { readState } from '../core/config.js';
+import { ApiCanvasSource, cliClient } from './api-client.js';
 import { getDefaultProfileId } from '../core/profiles/default-binding.js';
 export const browseLeaf = defineLeaf({
     name: 'browse',
@@ -41,13 +38,6 @@ export const browseLeaf = defineLeaf({
                 required: false,
                 constraint: 'Exact profile id for the initial profile filter (on by default; P toggles All profiles). Default: the launching node\'s profile via CRTR_PROFILE_ID, then this cwd\'s pinned default profile; absent means All profiles.',
             },
-            {
-                kind: 'flag',
-                name: 'canvas',
-                type: 'string',
-                required: false,
-                constraint: 'Read from the named remote canvas target (see `crtr canvas config list`) instead of the local canvas. Overrides `crtr canvas use`.',
-            },
         ],
         output: [],
         outputKind: 'object',
@@ -63,20 +53,7 @@ export const browseLeaf = defineLeaf({
             process.env['CRTR_PROFILE_ID'] ??
             getDefaultProfileId(cwd) ??
             undefined;
-        const canvasName = input['canvas'];
-        const source = cliCanvasSource({ canvasName });
-        // The EFFECTIVE remote target name — an explicit --canvas, or (mirroring
-        // resolveCanvasSource's own precedence) the durable `crtr canvas use`
-        // selection. Only a remote target needs an event stream; resolve its
-        // credentials ONCE here (not re-derived inside app.ts, which stays
-        // credential-agnostic).
-        const effectiveCanvasName = canvasName ?? readState('user').activeCanvas ?? undefined;
-        const eventStream = effectiveCanvasName !== undefined
-            ? (() => {
-                const { previewEndpoint, relayToken } = resolveRemoteCanvasTarget(effectiveCanvasName);
-                return new RemoteEventStream(previewEndpoint, relayToken);
-            })()
-            : undefined;
+        const source = new ApiCanvasSource();
         // The `x` close-out routes through the daemon API (browse `x` = finish the
         // root to `done`); the callback keeps app.ts off the openDb-reaching
         // runtime/close.js.
@@ -85,10 +62,7 @@ export const browseLeaf = defineLeaf({
             cwd,
             profileId,
             source,
-            eventStream,
-            viewedNodeIds: effectiveCanvasName === undefined
-                ? async () => new Set((await cliClient().listFocuses()).map((focus) => focus.node_id))
-                : undefined,
+            viewedNodeIds: async () => new Set((await cliClient().listFocuses()).map((focus) => focus.node_id)),
             closeNode: (id) => cliClient().closeNode(id, { finish: true }).then((r) => ({ closed: r.closed })),
         });
     },

package/dist/commands/canvas-config.js

@@ -31,7 +31,7 @@ function maskedTarget(name, target, secrets) {
 const canvasConfigAdd = defineLeaf({
     name: 'add',
     description: 'register a remote canvas target (preview endpoint + relay token)',
-    whenToUse: 'wiring up a remote canvas so `node inspect`, `canvas browse`, or `surface attach --canvas` can read it \u2014 stores the preview endpoint in config.json and the raw relay token in the 0600 secrets store (never together, never persisted to config.json or logged). Re-running with the same name overwrites both.',
+    whenToUse: 'wiring up a remote canvas so `node inspect` or `surface attach --canvas` can reach it \u2014 stores the preview endpoint in config.json and the raw relay token in the 0600 secrets store (never together, never persisted to config.json or logged). Re-running with the same name overwrites both.',
     help: {
         name: 'canvas config add',
         summary: 'register (or overwrite) a named remote canvas target',

package/dist/commands/canvas-use.js

@@ -1,5 +1,5 @@
-// `crtr canvas use` — durably select which canvas read commands
-// (`node inspect list/show`, `canvas browse`) default onto: a named remote
+// `crtr canvas use` — durably select which remote-capable read commands
+// (such as `node inspect list/show`) default onto: a named remote
 // target, or back to local. A single leaf, not a branch — there is exactly
 // one decision here (pick a target, or go local), not a family of verbs.
 import { defineLeaf } from '../core/command.js';
@@ -10,7 +10,7 @@ const SCOPE = 'user';
 export const canvasUseLeaf = defineLeaf({
     name: 'use',
     description: 'select the durable default canvas for read commands (a remote target, or local)',
-    whenToUse: 'switching what `node inspect list/show` and `canvas browse` read from by default, without passing `--canvas <name>` on every invocation \u2014 select a remote target registered via `crtr canvas config add`, or switch back to local. A command\u2019s own `--canvas <name>` flag always overrides this for that one call.',
+    whenToUse: 'switching what remote-capable read commands such as `node inspect list/show` read from by default, without passing `--canvas <name>` on every invocation \u2014 select a remote target registered via `crtr canvas config add`, or switch back to local. A command\u2019s own `--canvas <name>` flag always overrides this for that one call.',
     help: {
         name: 'canvas use',
         summary: 'select the durable default canvas (a registered remote target, or local) for read commands',

package/dist/commands/canvas.js

@@ -43,7 +43,7 @@ export function registerCanvas() {
         help: {
             name: 'canvas',
             summary: 'observe and supervise the whole agent graph',
-            model: 'Canvas-wide operations, distinct from per-node work (`node`) and a node\'s own spine write verb (`push`). `dashboard` renders the subscription forest as a tree; `browse` opens an interactive full-screen navigator (tabs/tree/search) over the whole canvas and resumes the chosen node; `attention` aggregates pending human asks across the graph; `revive --all` mass-reconnects every disconnected node (bringing back ONE named node is `node lifecycle revive <id>` instead); `history` searches and recalls the content record (reports + context docs) of past work in a cwd; `prune` bounds growth by deleting terminal nodes past a TTL. `config` registers/lists remote canvas targets (preview endpoint + relay token); `use` switches read commands (`node inspect`, `browse`) onto a configured remote target or back to local.',
+            model: 'Canvas-wide operations, distinct from per-node work (`node`) and a node\'s own spine write verb (`push`). `dashboard` renders the subscription forest as a tree; `browse` opens an interactive full-screen navigator (tabs/tree/search) over the whole canvas and resumes the chosen node; `attention` aggregates pending human asks across the graph; `revive --all` mass-reconnects every disconnected node (bringing back ONE named node is `node lifecycle revive <id>` instead); `history` searches and recalls the content record (reports + context docs) of past work in a cwd; `prune` bounds growth by deleting terminal nodes past a TTL. `config` registers/lists remote canvas targets (preview endpoint + relay token); `use` switches remote-capable read commands such as `node inspect` onto a configured target or back to local.',
         },
         children: [dashboardLeaf, canvasSnapshotLeaf, canvasRosterLeaf, browseLeaf, attentionBranch, reviveLeaf, historyBranch, chordLeaf, issueBranch, canvasPruneLeaf, canvasRebuildIndexLeaf, canvasConfigBranch, canvasUseLeaf],
     });

package/dist/commands/cron.js

@@ -496,8 +496,12 @@ const cancelLeaf = defineLeaf({
     },
     run: async (input) => {
         const id = requireCronId(input);
+        const runId = process.env['CRTR_RUN_ID'];
         await cliClient()
-            .cancelCron(id, scopeQuery())
+            .cancelCron(id, {
+            ...scopeQuery(),
+            ...(runId === undefined || runId === '' ? {} : { run_id: runId }),
+        })
             .catch((err) => rethrowAsCliError(err, 'Check the id against `crtr cron list`.'));
         return { canceled: id };
     },

package/dist/commands/human/queue.d.ts

@@ -1,8 +1,4 @@
-import type { Deck, InteractionResponse } from '../../core/human/types.js';
 export declare const humanList: import("../../core/command.js").LeafDef;
 export declare const humanDeck: import("../../core/command.js").LeafDef;
-/** Pure core of {@link coerceSingleSelect}, split out so it is testable without
- *  a deck.json on disk. */
-export declare function coerceSingleSelectAgainst(responses: InteractionResponse[], deck: Deck): InteractionResponse[];
 export declare const humanResolve: import("../../core/command.js").LeafDef;
 export declare const humanCancel: import("../../core/command.js").LeafDef;