@north-light/crouter 0.3.300 → 0.3.302

package/dist/api/dto/reports.d.ts

@@ -22,13 +22,13 @@ export interface PushReportResultDTO {
         from: string;
         to: string;
     };
-    /** Present (and true) only for a `final` push whose reporting node owned a
-     *  managed worktree with zero commits ahead of its base and no uncommitted
-     *  changes: the server auto-dropped it instead of blocking on `node worktree
-     *  close`. A worktree with real unlanded work instead blocks with
-     *  an `open_managed_worktree` error. */
+    /** Present (and true) only for a `final` push that closes the reporting
+     *  node's managed-worktree record without `node worktree close`. An existing
+     *  checkout must be clean with its tip contained in the local base and stays
+     *  pending cleanup; a missing checkout must be proven delivered. Work not
+     *  proven delivered blocks with an `open_managed_worktree` error. */
     worktree_auto_dropped?: boolean;
-    /** Present only alongside `worktree_auto_dropped`: the checkout path dropped. */
+    /** Present only alongside `worktree_auto_dropped`: the closed managed-worktree path; an existing checkout remains until pending cleanup. */
     worktree_auto_dropped_path?: string;
 }
 /** Why a node declined a structured result. `reason` is one plain sentence
@@ -55,8 +55,8 @@ export type SubmitResultRequest = {
     retryable: boolean;
 };
 /** Result of a structured-result submission (`crtr push result`). Terminal
- *  mode reuses the final-push machinery, so `transitioned` and the worktree
- *  auto-drop fields carry the same meaning as on PushReportResultDTO. */
+ *  mode reuses the final-push machinery, so `transitioned` and the managed-worktree
+ *  closure fields carry the same meaning as on PushReportResultDTO. */
 export interface SubmitResultDTO {
     /** Which request this answered: `terminal` finished the node; `oneoff` left it working. */
     mode: 'terminal' | 'oneoff';

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

@@ -2,13 +2,16 @@ import type { NodeRow } from '../../../core/canvas/types.js';
 interface ProfileFileSearchOptions {
     cwd: string;
     nodeDirs: readonly string[];
+    nodeIds: 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. */
+/** Return the ids of 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 relatedNodeIds(nodes: readonly Pick<NodeRow, 'node_id' | 'parent'>[], nodeId: string): string[];
+/** Return the working directories of the same node family. */
 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,22 +1,24 @@
 // session/profile-files.ts — fuzzy file search across a node's working family and local profile.
 //
 // 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.
+// node's workspace, the context and reports directories of those same nodes,
+// 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';
 import { execFile, spawnSync } from 'node:child_process';
 import { loadProfileManifest, profileMemoryDir } from '../../../core/profiles/manifest.js';
+import { contextDir, reportsDir } from '../../../core/canvas/paths.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) {
+/** Return the ids of 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 relatedNodeIds(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;) {
@@ -36,7 +38,27 @@ export function relatedNodeDirs(nodes, nodeId) {
             pending.push(child.node_id);
         }
     }
-    return nodes.filter((node) => included.has(node.node_id)).map((node) => node.cwd);
+    return nodes.filter((node) => included.has(node.node_id)).map((node) => node.node_id);
+}
+/** Return the working directories of the same node family. */
+export function relatedNodeDirs(nodes, nodeId) {
+    const family = new Set(relatedNodeIds(nodes, nodeId));
+    return nodes.filter((node) => family.has(node.node_id)).map((node) => node.cwd);
+}
+/** Return the canvas-home directories that hold each family node's shared
+ *  documents: its context dir and its pushed reports. These live outside every
+ *  working directory, so they are searched as roots of their own. */
+function familyDocumentDirs(nodeIds) {
+    const dirs = [];
+    for (const id of nodeIds) {
+        try {
+            dirs.push(contextDir(id), reportsDir(id));
+        }
+        catch {
+            continue;
+        }
+    }
+    return dedupeExistingDirs(dirs);
 }
 function isDirectory(path) {
     try {
@@ -163,8 +185,15 @@ export function launchProfileFileSearch(opts) {
     const tempDir = mkdtempSync(join(tmpdir(), 'crtr-profile-files-'));
     const selected = join(tempDir, 'selection');
     const candidates = join(tempDir, 'candidates');
+    // A context dir can hold a full repo clone a node made for itself, so ignore
+    // rules stay on (they are what keeps a clone's dependencies out) and the
+    // background-bash log dir directly beneath it is dropped — those are
+    // transient command output named by job id, never a document to open.
+    const documentDirs = familyDocumentDirs(opts.nodeIds)
+        .filter((dir) => !roots.some((root) => dir === root || dir.startsWith(root + sep)));
     const scans = [
         ...roots.map((root) => `${shellQuote(fd)} --type f --hidden --exclude .git --exclude ${shellQuote('**/.crouter/memory/**')} . ${shellQuote(root)}`),
+        ...documentDirs.map((dir) => `${shellQuote(fd)} --type f --hidden --exclude .git --exclude ${shellQuote('/jobs')} . ${shellQuote(dir)}`),
         ...memoryDirs.map((memory) => `${shellQuote(fd)} --type f --hidden --exclude .git --no-ignore . ${shellQuote(memory)}`),
     ];
     // Every line is the whole path and nothing else, so fzf matches, ranks, and