@north-light/crouter 0.3.170 → 0.3.172

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

@@ -0,0 +1,2 @@
+import { type BranchDef } from '../../core/command.js';
+export declare const humanDoc: BranchDef;

package/dist/commands/human/doc.js

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { defineBranch, defineLeaf } from '../../core/command.js';
+import { InputError } from '../../core/io.js';
+import { checkMarkdown, renderMarkdown } from '../../core/termrender/termrender.js';
+function markdownSource(input, context) {
+    const path = input['path'];
+    const body = input['body'];
+    const stdinProvided = context?.providedParams.has('body') === true;
+    if (path === undefined && !stdinProvided) {
+        throw new InputError({
+            error: 'missing_parameter',
+            message: 'provide exactly one markdown source: PATH or stdin',
+            next: 'Run `crtr human doc check -h` or `crtr human doc render -h` and provide a path or pipe markdown on stdin.',
+        });
+    }
+    if (path !== undefined && path !== '-' && stdinProvided && body.trim() !== '') {
+        throw new InputError({
+            error: 'bad_invocation',
+            message: 'both a positional path and piped stdin were provided',
+            field: 'path, body',
+            next: 'Pass exactly one markdown source: either PATH or piped stdin, not both.',
+        });
+    }
+    if (path === undefined || path === '-')
+        return body;
+    const abs = resolve(path);
+    if (!existsSync(abs)) {
+        throw new InputError({
+            error: 'file_not_found',
+            message: `file not found: ${abs}`,
+            field: 'path',
+            next: 'Provide a path to an existing markdown file, or pipe markdown on stdin.',
+        });
+    }
+    return readFileSync(abs, 'utf8');
+}
+const humanDocCheck = defineLeaf({
+    name: 'check',
+    description: 'validate a directive-flavored markdown body',
+    whenToUse: 'validating a deck or review body before submitting it.',
+    help: {
+        name: 'human doc check',
+        summary: 'validate directive-flavored markdown through the pinned managed renderer',
+        guide: 'The pinned renderer runs from a private managed venv and is not on PATH, so this is the only way to validate a deck or review body before submitting it.',
+        params: [
+            { kind: 'positional', name: 'path', type: 'path', required: false, constraint: 'Markdown file to validate. Provide exactly one of PATH or stdin; use - to read stdin.' },
+            { kind: 'stdin', name: 'body', required: false, constraint: 'Markdown to validate. Provide exactly one of piped stdin or PATH.' },
+        ],
+        output: [
+            { name: 'ok', type: 'boolean', required: true, constraint: 'True when the markdown is valid.' },
+            { name: 'error', type: 'string', required: false, constraint: 'The renderer validation error when ok is false.' },
+        ],
+        outputKind: 'object',
+        effects: ['Read-only: invokes the private managed renderer to validate the supplied body.'],
+    },
+    run: async (input, context) => checkMarkdown(markdownSource(input, context)),
+});
+const humanDocRender = defineLeaf({
+    name: 'render',
+    description: 'render a directive-flavored markdown body',
+    whenToUse: 'previewing how a deck or review body renders before submitting it.',
+    help: {
+        name: 'human doc render',
+        summary: 'render directive-flavored markdown through the pinned managed renderer',
+        guide: 'The pinned renderer runs from a private managed venv and is not on PATH, so this is the only way to render a deck or review body before submitting it.',
+        params: [
+            { kind: 'positional', name: 'path', type: 'path', required: false, constraint: 'Markdown file to render. Provide exactly one of PATH or stdin; use - to read stdin.' },
+            { kind: 'stdin', name: 'body', required: false, constraint: 'Markdown to render. Provide exactly one of piped stdin or PATH.' },
+            { kind: 'flag', name: 'width', type: 'int', required: false, default: process.stdout.columns || 100, constraint: 'Render width in columns. Default: current stdout width, or 100.' },
+            { kind: 'flag', name: 'color', type: 'bool', required: false, default: true, constraint: 'Emit ANSI color. Default true; false strips ANSI escape sequences.' },
+        ],
+        output: [
+            { name: 'lines', type: 'string[]', required: true, constraint: 'Rendered terminal lines in display order.' },
+            { name: 'width', type: 'integer', required: true, constraint: 'The render width in columns.' },
+        ],
+        outputKind: 'object',
+        effects: ['Read-only: invokes the private managed renderer to render the supplied body.'],
+    },
+    run: async (input, context) => {
+        const width = input['width'];
+        const color = input['color'];
+        const lines = renderMarkdown(markdownSource(input, context), width);
+        return { lines: color ? lines : lines.map((line) => line.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')), width };
+    },
+    render: (result) => result['lines'].join('\n'),
+});
+export const humanDoc = defineBranch({
+    name: 'doc',
+    description: 'validate or render directive-flavored markdown bodies',
+    whenToUse: 'validating or previewing a directive-flavored markdown body before submitting it.',
+    help: {
+        name: 'human doc',
+        summary: 'validate and render directive-flavored markdown bodies',
+        model: 'Both leaves read exactly one body from a path or stdin through the private managed renderer.',
+    },
+    children: [humanDocCheck, humanDocRender],
+});

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

@@ -0,0 +1,2 @@
+import { type BranchDef } from '../../core/command.js';
+export declare const humanInbox: BranchDef;

package/dist/commands/human/inbox.js

@@ -0,0 +1,101 @@
+import { defineBranch, defineLeaf } from '../../core/command.js';
+import { currentTmux, displayClientMessage, liveViewerPanes, paneLocation, selectPane, selectWindow, sendAttachControl, switchClient, } from '../../core/runtime/placement-tmux.js';
+const NO_VIEWER_MESSAGE = 'No crouter viewer is running — attach to a node first (crtr surface attach to <node>).';
+function tmuxSocketFromEnvironment() {
+    const socket = process.env['TMUX']?.split(',')[0]?.trim();
+    return socket === undefined || socket === '' ? undefined : socket;
+}
+function paneForInvocation(explicit) {
+    if (explicit !== undefined && explicit !== '')
+        return explicit;
+    const fromEnv = process.env['TMUX_PANE'];
+    if (fromEnv !== undefined && fromEnv !== '')
+        return fromEnv;
+    return currentTmux()?.pane;
+}
+function newestViewer(a, b) {
+    if (a.stampMs !== b.stampMs)
+        return b.stampMs - a.stampMs;
+    if (a.pane === b.pane)
+        return 0;
+    return a.pane < b.pane ? -1 : 1;
+}
+function selectViewer(viewers, targetPane, clientSession) {
+    const targeted = targetPane === undefined ? undefined : viewers.find((viewer) => viewer.pane === targetPane);
+    if (targeted !== undefined)
+        return targeted;
+    const inClientSession = clientSession === undefined ? [] : viewers.filter((viewer) => viewer.session === clientSession);
+    return [...(inClientSession.length > 0 ? inClientSession : viewers)].sort(newestViewer)[0];
+}
+function focusViewer(viewer, targetPane, clientSession) {
+    if (viewer.pane === targetPane)
+        return;
+    const location = paneLocation(viewer.pane);
+    if (location === null) {
+        selectPane(viewer.pane);
+        return;
+    }
+    if (clientSession !== location.session)
+        switchClient(location.session);
+    selectWindow(location.session, location.window);
+    selectPane(viewer.pane);
+}
+const humanInboxToggle = defineLeaf({
+    name: 'toggle',
+    description: 'deliver the inbox toggle to a live viewer',
+    whenToUse: 'toggling the human inbox surface in a running crouter viewer; the selected viewer receives the private attach-control action and is focused afterward.',
+    help: {
+        name: 'human inbox toggle',
+        summary: 'deliver the human inbox toggle to a live viewer',
+        guide: 'Selection prefers the target pane, then the resolved client session by newest viewer stamp, then newest globally; ties use pane id. The viewer decides whether the delivered toggle opens or closes the surface.',
+        params: [
+            { kind: 'flag', name: 'tmux-socket', type: 'path', required: false, constraint: 'Tmux server socket. Omit to use the first field of $TMUX.' },
+            { kind: 'flag', name: 'tmux-client', type: 'string', required: false, constraint: 'Tmux client name for the status-line message and client-session context.' },
+            { kind: 'flag', name: 'target-pane', type: 'string', required: false, constraint: 'Viewer pane to prefer. Omit to use $TMUX_PANE or the current tmux pane as the selection target.' },
+            { kind: 'flag', name: 'quiet', type: 'bool', required: false, default: false, constraint: 'Suppress the structured command result. A no-viewer status-line message is still shown.' },
+        ],
+        output: [
+            { name: 'action', type: 'opened | skipped', required: true, constraint: 'opened means the private inbox toggle sequence was delivered to a live viewer; it does not assert that the surface is now open. skipped means delivery did not happen.' },
+            { name: 'message', type: 'string', required: false, constraint: 'Present when action is skipped. With no live viewer, the same message is also shown in the tmux status line.' },
+        ],
+        outputKind: 'object',
+        effects: ['Sends the private inbox attach-control sequence to one live viewer and focuses that viewer unless it is already the target pane. Never opens a popup, launches a viewer, or wakes a node. With --quiet, suppresses only the structured result.'],
+    },
+    run: async (input) => {
+        const quiet = input['quiet'];
+        const socket = input['tmuxSocket'] ?? tmuxSocketFromEnvironment();
+        const client = input['tmuxClient'];
+        const targetPane = paneForInvocation(input['targetPane']);
+        if (socket === undefined) {
+            const outcome = { action: 'skipped', message: 'the inbox needs tmux' };
+            return quiet ? undefined : outcome;
+        }
+        const viewers = liveViewerPanes(socket);
+        const targetViewer = targetPane === undefined ? undefined : viewers.find((viewer) => viewer.pane === targetPane);
+        const clientSession = targetViewer?.session ?? (targetPane === undefined ? undefined : paneLocation(targetPane)?.session) ?? currentTmux()?.session;
+        const viewer = selectViewer(viewers, targetPane, clientSession);
+        if (viewer === undefined) {
+            displayClientMessage(socket, client, NO_VIEWER_MESSAGE);
+            const outcome = { action: 'skipped', message: NO_VIEWER_MESSAGE };
+            return quiet ? undefined : outcome;
+        }
+        if (!sendAttachControl(socket, viewer.pane, 'crtr.attach.inbox.toggle')) {
+            const outcome = { action: 'skipped', message: 'could not deliver the inbox toggle to the selected viewer' };
+            return quiet ? undefined : outcome;
+        }
+        focusViewer(viewer, targetPane, clientSession);
+        const outcome = { action: 'opened' };
+        return quiet ? undefined : outcome;
+    },
+});
+export const humanInbox = defineBranch({
+    name: 'inbox',
+    description: 'deliver the human inbox toggle to a live viewer',
+    whenToUse: 'answering, reviewing, or managing pending human tickets from a running crouter viewer.',
+    help: {
+        name: 'human inbox',
+        summary: 'deliver the human inbox toggle to a live viewer',
+        model: 'The toggle leaf sends a private viewer control action; it never hosts the inbox itself.',
+    },
+    children: [humanInboxToggle],
+});

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

@@ -1,8 +1,7 @@
-import type { DeckSource } from '@crouton-kit/humanloop';
-/** Humanloop's optional presentation label. Ticket identity and attribution
+import type { DeckSource } from '../../core/human/types.js';
+/** Optional presentation label for crouter tickets. Ticket identity and attribution
  * come from the bridge node directory and parent relation, never ticket data. */
 export declare function sourceStamp(): Promise<DeckSource>;
 export declare const humanAsk: import("../../core/command.js").LeafDef;
-export declare const humanReview: import("../../core/command.js").LeafDef;
 export declare const humanNotify: import("../../core/command.js").LeafDef;
 export declare const humanShow: import("../../core/command.js").LeafDef;

package/dist/commands/human/prompts.js

@@ -6,21 +6,23 @@
 import { defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { cliClient } from '../api-client.js';
-import { nodeDir } from '../../core/canvas/paths.js';
-import { mkdirSync, existsSync } from 'node:fs';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { randomBytes, randomUUID } from 'node:crypto';
+import { dirname, isAbsolute, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
 import { tmuxServerReachable } from '../../core/spawn.js';
-import { BrokerClient, BrokerUnavailableError } from '../../core/broker-client/index.js';
 import { markStopSignal } from '../../core/runtime/stop-signals.js';
-import { validateDeck, resolveDeckBodyPaths, notifyDeck, atomicWriteJson, submitDeck, submitReview, display, } from '@crouton-kit/humanloop';
-import { BODY_PATH_CONTRACT, DECK_SCHEMA_HINT, registerCrouterRoot, resolveMaxPanes } from './shared.js';
-import { inboxOpenInstruction, inboxPopupHint } from '../../core/keybindings/index.js';
+import { validateDeck, resolveDeckBodyPaths } from '../../core/human/deck-schema.js';
+import { notifyDeck } from '../../core/human/deck-factories.js';
+import { atomicWriteJson } from '../../core/human/convention.js';
+import { ticketDir } from '../../core/human/root.js';
+import { submitDeck } from '../../core/human/tickets.js';
+import { display } from '../../core/termrender/display.js';
+import { BODY_PATH_CONTRACT, DECK_SCHEMA_HINT, resolveMaxPanes } from './shared.js';
+import { inboxHint, inboxOpenInstruction } from '../../core/keybindings/index.js';
 /** The asking node's id, or null when run from a bare shell (no parent to route to). */
 function askingNode() {
     return process.env['CRTR_NODE_ID'] ?? null;
 }
-/** Humanloop's optional presentation label. Ticket identity and attribution
+/** Optional presentation label for crouter tickets. Ticket identity and attribution
  * come from the bridge node directory and parent relation, never ticket data. */
 export async function sourceStamp() {
     const nodeId = askingNode();
@@ -88,7 +90,7 @@ function buildHumanAskDeck(title, subtitle, question) {
     });
 }
 /** Crouter authors decision decks by default. Persist the explicit kind so
- * consumers can rely on Humanloop's strict interaction-kind contract. */
+ * consumers can rely on the ticket store's strict interaction-kind contract. */
 function canonicalizeAskKinds(deck) {
     return {
         ...deck,
@@ -98,54 +100,6 @@ function canonicalizeAskKinds(deck) {
         })),
     };
 }
-const HUMAN_FORK_COORDINATES_TIMEOUT_MS = 10_000;
-const EXACT_MODEL_SPEC = /^[^/\s:]+\/[^/\s:]+:(?:off|minimal|low|medium|high|xhigh|max)$/;
-class InvalidHumanForkCoordinatesError extends Error {
-}
-class InvalidHumanForkModelError extends Error {
-}
-/** Read one pure ask-time coordinate from the source broker. Materialization is
- * deliberately separate so this observer connection can never change its live
- * session manager. */
-function getHumanForkCoordinates(nodeId) {
-    return new Promise((resolve, reject) => {
-        const client = new BrokerClient(nodeId);
-        let settled = false;
-        const timer = setTimeout(() => finish(() => reject(new BrokerUnavailableError(nodeId))), HUMAN_FORK_COORDINATES_TIMEOUT_MS);
-        if (typeof timer.unref === 'function')
-            timer.unref();
-        function finish(act) {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            client.close();
-            act();
-        }
-        client.on('error', () => finish(() => reject(new BrokerUnavailableError(nodeId))));
-        client.on('close', () => finish(() => reject(new BrokerUnavailableError(nodeId))));
-        client.on('connect', () => {
-            client.send({ type: 'hello', role: 'observer', client_id: randomUUID() });
-            client
-                .request({ type: 'get_human_fork_coordinates' })
-                .then((frame) => finish(() => resolve(frame)))
-                .catch(() => finish(() => reject(new BrokerUnavailableError(nodeId))));
-        });
-        client.connect();
-    });
-}
-function assertHumanForkCoordinates(coordinates) {
-    if (coordinates.kind !== 'human_fork_coordinates' || !isAbsolute(coordinates.sourceFile) || coordinates.sourceSessionId === '' || coordinates.leafId === '') {
-        throw new InvalidHumanForkCoordinatesError('broker returned invalid human fork coordinates');
-    }
-    if (coordinates.modelSpec === null || !EXACT_MODEL_SPEC.test(coordinates.modelSpec)) {
-        throw new InvalidHumanForkModelError('broker returned no exact human fork model');
-    }
-}
-function unavailableForkDetail(err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    return detail === '' ? undefined : detail.slice(0, 240);
-}
 /** The non-blocking status peek returned by ask/review. Resolved per call so
  *  the inbox affordance reflects the human's current keybinding (or the CLI
  *  fallback when the toggle is disabled). */
@@ -161,8 +115,8 @@ export const humanAsk = defineLeaf({
     whenToUse: 'you would otherwise lay a decision, a set of options, or a question out for the user as prose — reach for this instead, for anything from a quick yes/no to a judgment-heavy call: gating a handoff, merge, deploy, destructive/irreversible operation, or real budget on an explicit human sign-off (offer Yes/No options), reviewing all the requirements before building, choosing among implementation patterns, walking a list of risks and deciding what to do about each, settling a naming or scope question, picking which of several findings to act on. Works for open-ended asks too (set `allowFreetext`, offer a few `options` as starting points).',
     help: {
         name: 'human ask',
-        summary: 'put a humanloop decision deck in front of a person; returns a job handle immediately.',
-        guide: 'Write every interaction as a self-contained decision brief for a supervisor who has not followed this agent or task: use the title to identify the inbox topic; write a one-sentence subtitle stating the decision, your recommendation, and what it changes; then give the minimum plain-language context and tradeoffs needed to decide in the body. Never coin a term, code name, or shorthand for a system, mechanism, or state, and expand any project-internal name you do use: name the thing plainly and say what it does. Invented vocabulary is not compression — the reader has to decode it before they can decide. Put supporting evidence, chronology, and technical detail under `## Details` so the person can answer without logs, screenshots, or prior conversation. For a simple open-text question, supply the short topic with --title, the required sentence with --subtitle, and pipe the markdown body on stdin. Use --context-file for a fully structured deck; its deck title and every interaction title and subtitle are required. The deck body is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `termrender doc -h` for the directive set before authoring one. Ask only what materially changes your next step, and offer genuine alternatives as `options`.',
+        summary: "submit a decision ticket to crouter's inbox; returns a job handle immediately.",
+        guide: 'Write every interaction as a self-contained decision brief for a supervisor who has not followed this agent or task: use the title to identify the inbox topic; write a one-sentence subtitle stating the decision, your recommendation, and what it changes; then give the minimum plain-language context and tradeoffs needed to decide in the body. Never coin a term, code name, or shorthand for a system, mechanism, or state, and expand any project-internal name you do use: name the thing plainly and say what it does. Invented vocabulary is not compression — the reader has to decode it before they can decide. Put supporting evidence, chronology, and technical detail under `## Details` so the person can answer without logs, screenshots, or prior conversation. For a simple open-text question, supply the short topic with --title, the required sentence with --subtitle, and pipe the markdown body on stdin. Use --context-file for a fully structured deck; its deck title and every interaction title and subtitle are required. The deck body is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `crtr human doc check` before authoring one. Ask only what materially changes your next step, and offer genuine alternatives as `options`.',
         params: [
             { kind: 'flag', name: 'title', type: 'string', required: false, constraint: 'Required with stdin: a short ≤~4-word inbox topic. Mutually exclusive with --context-file, whose JSON carries its own required title.' },
             { kind: 'flag', name: 'subtitle', type: 'string', required: false, constraint: 'Required with stdin: one plain-English sentence stating the decision, recommendation, and stakes. Mutually exclusive with --context-file, whose JSON requires every interaction subtitle.' },
@@ -176,8 +130,8 @@ export const humanAsk = defineLeaf({
         ],
         outputKind: 'object',
         effects: [
-            'Creates a kind:"human" node under you and enqueues a decision deck in the humanloop inbox.',
-            `Returns immediately; nothing opens on screen. The human answers from the inbox popup (${inboxPopupHint()}) on their own time.`,
+            'Creates a kind:"human" node under you and enqueues a decision deck in the human inbox.',
+            `Returns immediately; nothing opens on screen. The human answers from the inbox (${inboxHint()}) on their own time.`,
         ],
     },
     run: async (input, context) => {
@@ -228,125 +182,20 @@ export const humanAsk = defineLeaf({
         }
         // Crouter owns this provenance. Never synthesize labels from deck content:
         // an unavailable daemon leaves only machine attribution for routing.
-        deck = { ...deck, source: { ...await sourceStamp(), visual: 'humanloop.visual/v1' } };
+        deck = { ...deck, source: await sourceStamp() };
         const cwd = process.cwd();
         const jobId = (await cliClient().createHumanBridge({ kind: 'human', parent: askingNode(), cwd, name: 'human-ask' })).node_id;
-        const idir = nodeDir(jobId);
-        mkdirSync(idir, { recursive: true });
+        const idir = ticketDir(jobId);
         const rc = { mode: 'ask', job_id: jobId };
-        const capturedAt = new Date().toISOString();
-        const originNodeId = askingNode();
-        if (originNodeId === null) {
-            rc.conversation_fork = { status: 'unavailable', reason: 'no_origin', captured_at: capturedAt };
-        }
-        else {
-            try {
-                const coordinates = await getHumanForkCoordinates(originNodeId);
-                assertHumanForkCoordinates(coordinates);
-                // Loaded on demand: session-branch pulls pi's SessionManager, whose
-                // module graph costs ~385ms. Only a conversation fork needs it, so a
-                // static import would charge that to EVERY `crtr human` invocation.
-                const { materializeSessionBranchAt } = await import('../../core/runtime/session-branch.js');
-                materializeSessionBranchAt(coordinates, join(idir, 'branch-point.jsonl'));
-                rc.conversation_fork = {
-                    status: 'ready',
-                    source_node_id: originNodeId,
-                    source_file: coordinates.sourceFile,
-                    source_session_id: coordinates.sourceSessionId,
-                    leaf_id: coordinates.leafId,
-                    model_spec: coordinates.modelSpec,
-                    branch_point: 'branch-point.jsonl',
-                    captured_at: new Date().toISOString(),
-                };
-            }
-            catch (err) {
-                const reason = err instanceof BrokerUnavailableError
-                    ? 'broker_unavailable'
-                    : err instanceof InvalidHumanForkCoordinatesError
-                        ? 'invalid_coordinates'
-                        : err instanceof InvalidHumanForkModelError
-                            ? 'invalid_model'
-                            : 'materialization_failed';
-                rc.conversation_fork = {
-                    status: 'unavailable',
-                    reason,
-                    detail: unavailableForkDetail(err),
-                    captured_at: capturedAt,
-                };
-            }
-        }
         atomicWriteJson(join(idir, 'run.json'), rc);
-        const root = registerCrouterRoot();
-        const { dir } = submitDeck({ root, id: jobId, deck });
+        const { dir } = submitDeck({ dir: ticketDir(jobId), deck });
+        const originNodeId = askingNode();
         if (originNodeId !== null && originNodeId !== '')
             markStopSignal(originNodeId, 'askedHuman');
         return { job_id: jobId, dir, follow_up: queuedFollowUp() };
     },
 });
 // ---------------------------------------------------------------------------
-// review
-// ---------------------------------------------------------------------------
-export const humanReview = defineLeaf({
-    name: 'review',
-    description: 'collect anchored comments on a document or source file',
-    whenToUse: 'a human should comment line-by-line on a document rather than give one overall answer: reviewing a plan or spec before you build it, marking up a draft, flagging specific sections to change. The comments come back anchored to the lines they touch. Use `ask` instead for a single yes/no sign-off on the whole thing, or to pose a discrete choice',
-    help: {
-        name: 'human review',
-        summary: "queue a .md artifact or a source file for anchored, line-by-line human comments; returns a job handle instantly (a non-blocking kickoff, like ask). The human opens it from the inbox popup, which previews the live doc and re-reads it on every save, so edit in place rather than re-presenting.",
-        guide: `A kickoff, not a blocking call: it returns at once and the human reviews on their own time from the inbox (${inboxPopupHint()}). When they submit, the FeedbackResult (anchored comments, plus any line edits they made) is pushed to your inbox — waking you — and autosaved to \`output\`. The inbox preview is a LIVE view of the file: keep editing it in place and it updates, so do not cancel and re-present to show a change. Write the subtitle and the document itself in plain words: no coined terms or internal shorthand for a system or concept — name it and explain what it does, with enough context for someone who has not followed this work. A .md file is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see \`termrender doc -h\` for the directive set before authoring one. Any other UTF-8 text file (a .ts/.py/.sql source) is reviewed as a syntax-highlighted source panel anchored to its real line numbers; limits are 2 MB and 5,000 lines.`,
-        params: [
-            { kind: 'positional', name: 'file', type: 'path', required: true, constraint: 'Absolute path to an existing UTF-8 text file: a .md artifact, or a source file to review as code.' },
-            { kind: 'flag', name: 'subtitle', type: 'string', required: true, constraint: 'One plain-English sentence stating what review feedback is needed and why it matters.' },
-            { kind: 'flag', name: 'output', type: 'path', required: false, constraint: 'Where the FeedbackResult JSON is written. Default: <dir>/feedback.json.' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Node id of the kind:"human" node backing this review. Its FeedbackResult is pushed to your inbox when the human submits.' },
-            { name: 'dir', type: 'string', required: true, constraint: 'Interaction directory holding run.json and the autosaved feedback.json.' },
-            { name: 'output', type: 'string', required: true, constraint: 'Path the FeedbackResult JSON is autosaved to when the human submits.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'A non-blocking status peek; comments arrive via your inbox when the human submits.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Creates a kind:"human" node under you and enqueues an anchored review in the humanloop inbox.',
-            `Returns immediately; nothing opens on screen. The human reviews from the inbox popup (${inboxPopupHint()}); comments fan into your inbox when they submit.`,
-        ],
-    },
-    run: async (input) => {
-        const fileArg = input['file'];
-        const abs = resolve(fileArg);
-        if (!existsSync(abs)) {
-            throw new InputError({
-                error: 'file_not_found',
-                message: `file not found: ${abs}`,
-                field: 'file',
-                next: 'Provide an absolute path to an existing file.',
-            });
-        }
-        const subtitle = requireSubtitle(input['subtitle']);
-        const cwd = process.cwd();
-        const jobId = (await cliClient().createHumanBridge({ kind: 'human', parent: askingNode(), cwd, name: 'human-review' })).node_id;
-        const idir = nodeDir(jobId);
-        mkdirSync(idir, { recursive: true });
-        const rc = { mode: 'review', job_id: jobId };
-        atomicWriteJson(join(idir, 'run.json'), rc);
-        const outputArg = input['output'];
-        const root = registerCrouterRoot();
-        const { dir } = submitReview({
-            root,
-            id: jobId,
-            review: {
-                file: abs,
-                ...(outputArg !== undefined ? { output: resolve(outputArg) } : {}),
-                title: abs.split('/').pop() ?? abs,
-                subtitle,
-                source: await sourceStamp(),
-            },
-        });
-        const output = outputArg !== undefined ? resolve(outputArg) : join(dir, 'feedback.json');
-        return { job_id: jobId, dir, output, follow_up: queuedFollowUp() };
-    },
-});
-// ---------------------------------------------------------------------------
 // notify (no job)
 // ---------------------------------------------------------------------------
 export const humanNotify = defineLeaf({
@@ -356,14 +205,14 @@ export const humanNotify = defineLeaf({
     help: {
         name: 'human notify',
         summary: 'enqueue a fire-and-forget acknowledgement in the human inbox; creates no job',
-        guide: 'State what happened in plain words — no coined terms or internal shorthand for a system or concept; name it and say what it does. The body is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `termrender doc -h` for the directive set before authoring one.',
+        guide: 'State what happened in plain words — no coined terms or internal shorthand for a system or concept; name it and say what it does. The body is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `crtr human doc check` before authoring one.',
         params: [
             { kind: 'positional', name: 'title', type: 'string', required: true, constraint: 'The notification headline.' },
             { kind: 'flag', name: 'subtitle', type: 'string', required: true, constraint: 'One plain-English sentence stating the notification status and stakes.' },
             { kind: 'flag', name: 'body', type: 'string', required: false, constraint: 'Optional markdown body.' },
         ],
         output: [
-            { name: 'queued', type: 'boolean', required: true, constraint: 'Always true — the notify deck is durable inbox state the human acknowledges from the popup.' },
+            { name: 'queued', type: 'boolean', required: true, constraint: 'Always true — the notify deck is durable inbox state the human acknowledges from the inbox.' },
             { name: 'dir', type: 'string', required: true, constraint: 'Interaction directory holding deck.json.' },
         ],
         outputKind: 'object',
@@ -378,12 +227,10 @@ export const humanNotify = defineLeaf({
         let deck = notifyDeck(title, { subtitle, ...(body !== undefined ? { body } : {}) });
         deck = { ...deck, source: await sourceStamp() };
         const id = `nfy-${randomBytes(4).toString('hex')}`;
-        const idir = nodeDir(id);
-        mkdirSync(idir, { recursive: true });
+        const idir = ticketDir(id);
         const rc = { mode: 'notify' };
         atomicWriteJson(join(idir, 'run.json'), rc);
-        const root = registerCrouterRoot();
-        const { dir } = submitDeck({ root, id, deck });
+        const { dir } = submitDeck({ dir: ticketDir(id), deck });
         return { queued: true, dir };
     },
 });
@@ -398,8 +245,8 @@ export const humanShow = defineLeaf({
     whenToUse: 'displaying a doc on screen while a human comments',
     help: {
         name: 'human show',
-        summary: 'put a file live on screen in a tmux pane via humanloop display',
-        guide: 'The pane always watches the file and live-updates on every save — a displayed doc is a live view by definition, so point it at a file something keeps rewriting (a status board, a running summary) and it stays current. The file is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `termrender doc -h` for the directive set before authoring one.',
+        summary: "put a file live on screen in a tmux pane with crouter's renderer",
+        guide: 'The pane always watches the file and live-updates on every save — a displayed doc is a live view by definition, so point it at a file something keeps rewriting (a status board, a running summary) and it stays current. The file is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `crtr human doc render` before authoring one.',
         params: [
             { kind: 'positional', name: 'path', type: 'path', required: true, constraint: 'Path to the file to render.' },
             { kind: 'flag', name: 'window', type: 'enum', choices: ['auto', 'split', 'new'], required: false, default: 'auto', constraint: 'Placement. Default auto.' },
@@ -416,7 +263,7 @@ export const humanShow = defineLeaf({
         const windowArg = input['window'];
         const window = windowArg !== undefined ? windowArg : 'auto';
         // `human show` must never fail the caller: any display error degrades to
-        // {pane_id:null, reason} with exit 0 (matches humanloop display semantics).
+        // {pane_id:null, reason} with exit 0 (matches crouter renderer display semantics).
         let paneId;
         try {
             const r = display(path, { window, maxPanes: resolveMaxPanes() });

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

@@ -1,4 +1,4 @@
-import type { Deck, InteractionResponse } from '@crouton-kit/humanloop';
+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
@@ -6,7 +6,3 @@ export declare const humanDeck: import("../../core/command.js").LeafDef;
 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;
-export declare const humanDeliver: import("../../core/command.js").LeafDef;
-export declare const humanConsult: import("../../core/command.js").LeafDef;
-export declare const humanVisual: import("../../core/command.js").LeafDef;
-export declare const humanFocus: import("../../core/command.js").LeafDef;