@north-light/crouter 0.3.227 → 0.3.229

package/dist/clients/attach/session/pane-tag.js

@@ -5,50 +5,76 @@
 // local id) from that pane. `@crtr_attach` carries no identity: every local or
 // remote attach viewer sets it so tmux can conditionally forward opted-in root
 // gestures into whichever attach pane currently has focus.
-import { currentTmux, setPaneOption, stampViewerPaneAsync, VIEWER_STAMP_OPTION, } from '../../../core/runtime/placement-tmux.js';
-/** The tag's lifecycle for one viewer: `set()` once the startup checkpoint has
- *  cleared, `clear()` on teardown so a stray tag can't outlive the pane.
- *  `pane()` is the id teardown reports as this viewer's home.
- *
- *  Split into a claim + a clear because ordering matters: a remote relay's "no
- *  node"/"no running broker" close can still throw AFTER the socket is up, so
- *  the tag is claimed only past that checkpoint — while `clear()` must be safe
- *  to call from a teardown that runs before it was ever claimed. */
-export function createPaneTag(remote, nodeId) {
+import { currentTmux, getPaneOption, setPaneOption, stampViewerPaneAsync, VIEWER_STAMP_OPTION, } from '../../../core/runtime/placement-tmux.js';
+const realPaneTagIo = {
+    readOption: getPaneOption,
+    writeOption: (pane, name, value) => { setPaneOption(pane, name, value); },
+    stampAsync: stampViewerPaneAsync,
+    currentPane: () => process.env['TMUX_PANE'] ?? currentTmux()?.pane,
+    ownerId: () => String(process.pid),
+};
+export function createPaneTag(remote, nodeId, io = realPaneTagIo) {
     let pane;
+    const ownerPid = io.ownerId();
+    /** False once another viewer's pid is on the pane. An unclaimed pane (no pid
+     *  recorded — a viewer that never reached `set()`, or one from a generation
+     *  that predates this option) keeps the old unconditional behavior. */
+    const stillOwnsPane = () => {
+        if (pane === undefined || pane === '')
+            return true;
+        const claimed = io.readOption(pane, VIEWER_OWNER_OPTION);
+        if (claimed === undefined || claimed === '')
+            return true;
+        return claimed === ownerPid;
+    };
     return {
         set: () => {
-            pane = process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-            tagAttachPane(remote, pane, nodeId);
-            tagAttachViewerPane(pane);
-            stampAttachPane(remote, pane);
+            pane = io.currentPane();
+            claimAttachPane(pane, ownerPid, io.writeOption);
+            tagAttachPane(remote, pane, nodeId, io.writeOption);
+            tagAttachViewerPane(pane, io.writeOption);
+            stampAttachPane(remote, pane, io.writeOption);
         },
         stamp: () => {
             if (remote || pane === undefined || pane === '')
                 return;
-            stampViewerPaneAsync(pane);
+            io.stampAsync(pane);
         },
         clear: () => {
-            untagAttachPane(remote, pane);
-            untagAttachViewerPane(pane);
-            unstampAttachPane(remote, pane);
+            if (!stillOwnsPane())
+                return;
+            untagAttachPane(remote, pane, io.writeOption);
+            untagAttachViewerPane(pane, io.writeOption);
+            unstampAttachPane(remote, pane, io.writeOption);
+            claimAttachPane(pane, '', io.writeOption);
         },
         pane: () => pane,
     };
 }
-function stampAttachPane(remote, pane) {
+/** Which viewer process owns this pane's tags. Read only by `clear()`, so a
+ *  departing viewer never removes a successor's identity. */
+export const VIEWER_OWNER_OPTION = '@crtr_viewer_pid';
+function claimAttachPane(pane, ownerPid, setOpt) {
+    if (pane === undefined || pane === '')
+        return;
+    try {
+        setOpt(pane, VIEWER_OWNER_OPTION, ownerPid);
+    }
+    catch { /* best-effort */ }
+}
+function stampAttachPane(remote, pane, setOpt) {
     if (remote || pane === undefined || pane === '')
         return;
     try {
-        setPaneOption(pane, VIEWER_STAMP_OPTION, String(Date.now()));
+        setOpt(pane, VIEWER_STAMP_OPTION, String(Date.now()));
     }
     catch { /* best-effort */ }
 }
-function unstampAttachPane(remote, pane) {
+function unstampAttachPane(remote, pane, setOpt = setPaneOption) {
     if (remote || pane === undefined || pane === '')
         return;
     try {
-        setPaneOption(pane, VIEWER_STAMP_OPTION, '');
+        setOpt(pane, VIEWER_STAMP_OPTION, '');
     }
     catch { /* best-effort */ }
 }

package/dist/clients/attach/session/profile-files.d.ts

@@ -1,8 +1,14 @@
+import type { NodeRow } from '../../../core/canvas/types.js';
 interface ProfileFileSearchOptions {
     cwd: string;
+    nodeDirs: readonly string[];
     profileId: string | null;
     fdPath: string | null;
     onNotice: (message: string) => void;
 }
+/** Return the working directories for this node, its complete parent chain,
+ *  and its full descendant subtree. The `parent` hierarchy, rather than the
+ *  subscription graph, is the user-visible child/parent relationship. */
+export declare function relatedNodeDirs(nodes: readonly Pick<NodeRow, 'node_id' | 'cwd' | 'parent'>[], nodeId: string): string[];
 export declare function launchProfileFileSearch(opts: ProfileFileSearchOptions): void;
 export {};

package/dist/clients/attach/session/profile-files.js

@@ -1,11 +1,11 @@
-// session/profile-files.ts — fuzzy file search across a node's local profile.
+// session/profile-files.ts — fuzzy file search across a node's working family and local profile.
 //
-// The popup searches the current workspace, every project named by the node's
-// profile manifest, and the profile's own memory store. Ancestor
-// `.crouter/memory/` stores are added with ignore rules disabled, so project
-// memory remains findable even when a parent ignore file hides `.crouter/`.
-// fzf owns selection and nvim owns viewing; the attach viewer only resolves the
-// relevant roots and wires the two popups.
+// The popup searches the current workspace, every ancestor and descendant
+// node's workspace, every project named by the node's profile manifest, and the
+// profile's own memory store. Ancestor `.crouter/memory/` stores are added with
+// ignore rules disabled, so project memory remains findable even when a parent
+// ignore file hides `.crouter/`. fzf owns matching and selection and nvim owns
+// viewing; the attach viewer resolves the related nodes and wires the two popups.
 import { constants, accessSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, dirname, join, resolve, sep } from 'node:path';
@@ -13,6 +13,31 @@ import { execFile, spawnSync } from 'node:child_process';
 import { loadProfileManifest, profileMemoryDir } from '../../../core/profiles/manifest.js';
 import { shellQuote } from '../../../core/runtime/placement-tmux.js';
 import { surfaceTmuxStyleArgs } from '../../../core/runtime/surface-bg.js';
+/** Return the working directories for this node, its complete parent chain,
+ *  and its full descendant subtree. The `parent` hierarchy, rather than the
+ *  subscription graph, is the user-visible child/parent relationship. */
+export function relatedNodeDirs(nodes, nodeId) {
+    const byId = new Map(nodes.map((node) => [node.node_id, node]));
+    const included = new Set([nodeId]);
+    for (let current = byId.get(nodeId); current?.parent !== null && current?.parent !== undefined;) {
+        const parentId = current.parent;
+        if (included.has(parentId))
+            break;
+        included.add(parentId);
+        current = byId.get(parentId);
+    }
+    const pending = [nodeId];
+    while (pending.length > 0) {
+        const parentId = pending.pop();
+        for (const child of nodes) {
+            if (child.parent !== parentId || included.has(child.node_id))
+                continue;
+            included.add(child.node_id);
+            pending.push(child.node_id);
+        }
+    }
+    return nodes.filter((node) => included.has(node.node_id)).map((node) => node.cwd);
+}
 function isDirectory(path) {
     try {
         return statSync(path).isDirectory();
@@ -93,6 +118,9 @@ function ancestorMemoryDirs(pointers) {
     }
     return dedupeExistingDirs(found);
 }
+/** Columns fzf keeps to the right of the matched substring when it scrolls a
+ *  long path into view. Wide enough to show the rest of the filename. */
+const HSCROLL_OFF = 20;
 function selectionPath(path) {
     try {
         const bytes = readFileSync(path);
@@ -122,7 +150,7 @@ export function launchProfileFileSearch(opts) {
         return;
     }
     const profile = profileSearchRoots(opts.profileId);
-    const pointers = dedupeExistingDirs([opts.cwd, ...profile.projects]);
+    const pointers = dedupeExistingDirs([opts.cwd, ...opts.nodeDirs, ...profile.projects]);
     if (pointers.length === 0) {
         opts.onNotice('No profile file-search directories exist');
         return;
@@ -134,11 +162,16 @@ export function launchProfileFileSearch(opts) {
     ]);
     const tempDir = mkdtempSync(join(tmpdir(), 'crtr-profile-files-'));
     const selected = join(tempDir, 'selection');
+    const candidates = join(tempDir, 'candidates');
     const scans = [
-        ...roots.map((root) => `${shellQuote(fd)} --type f --hidden --exclude .git --exclude ${shellQuote('**/.crouter/memory/**')} --print0 . ${shellQuote(root)}`),
-        ...memoryDirs.map((memory) => `${shellQuote(fd)} --type f --hidden --exclude .git --no-ignore --print0 . ${shellQuote(memory)}`),
+        ...roots.map((root) => `${shellQuote(fd)} --type f --hidden --exclude .git --exclude ${shellQuote('**/.crouter/memory/**')} . ${shellQuote(root)}`),
+        ...memoryDirs.map((memory) => `${shellQuote(fd)} --type f --hidden --exclude .git --no-ignore . ${shellQuote(memory)}`),
     ];
-    const command = `{ ${scans.map((scan) => `${scan} &`).join(' ')} wait; } | ${shellQuote(fzf)} --read0 --print0 --preview ${shellQuote('head -100 -- {}')} > ${shellQuote(selected)}`;
+    // Every line is the whole path and nothing else, so fzf matches, ranks, and
+    // horizontally scrolls against the same text — a hidden field would be
+    // unsearchable, and a display slice would silently narrow the query.
+    const yankPath = 'printf \'%s\' {} | { if command -v pbcopy >/dev/null 2>&1; then pbcopy; elif command -v wl-copy >/dev/null 2>&1; then wl-copy; elif command -v xclip >/dev/null 2>&1; then xclip -selection clipboard; else cat >/dev/null; fi; }; printf \'%s\' {} | tmux load-buffer -w -';
+    const command = `{ ${scans.map((scan) => `${scan} &`).join(' ')} wait; } > ${shellQuote(candidates)} && ${shellQuote(fzf)} --print0 --scheme=path --hscroll-off=${HSCROLL_OFF} --header ${shellQuote('fuzzy path • ctrl-y yank file path')} --bind ${shellQuote(`ctrl-y:execute-silent(${yankPath})`)} --preview ${shellQuote('head -100 -- {}')} < ${shellQuote(candidates)} > ${shellQuote(selected)}`;
     try {
         execFile('tmux', ['display-popup', '-E', '-T', ' profile files ', '-w', '80%', '-h', '60%', ...surfaceTmuxStyleArgs(), command], () => {
             const file = selectionPath(selected);

package/dist/clients/attach/slash/dispatch.js

@@ -396,11 +396,8 @@ function dispatchCanvasCommand(name, arg, ctx) {
             return true;
     }
 }
-/** `/promote [kind]` — the live promote path (the broker is headless, so promotion
- *  has no in-engine command). Shells `crtr node promote --json` for
- *  this node (out-of-process), notifies the result, then triggers a turn so the
- *  persona injector steers in the new-role guidance at the turn boundary — exactly
- *  as the node would by running the command itself. */
+/** `/promote [kind]` shells the out-of-process mutation, reports it, then
+ * triggers a turn whose provider gate appends the pending transition context. */
 function promoteNode(arg, ctx) {
     const nodeId = nodeIdFor(ctx).trim();
     if (nodeId === '') {
@@ -446,8 +443,8 @@ function promoteNode(arg, ctx) {
         }
         const rmPath = (result.roadmap_path ?? '').trim();
         ctx.notify(`Promoted to ${result.kind ?? 'orchestrator'} orchestrator — authoring roadmap${rmPath !== '' ? ` (${rmPath})` : ''}.`);
-        // Trigger a turn so the persona injector (canvas-stophook turn_end) fires and
-        // delivers the new-role guidance — the viewer's only turn-trigger is `prompt`.
+        // Trigger a turn so the pending transition lands before the promoted
+        // node's response; the viewer's only turn trigger is `prompt`.
         ctx.send({
             type: 'prompt',
             text: 'You have just been promoted to an orchestrator. Your new-role guidance is arriving — read it, author your roadmap, and start delegating.',