@north-light/crouter 0.3.162 → 0.3.163

package/dist/core/runtime/tmux.js

@@ -11,7 +11,7 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { formatGesture, resolveUserKeybindings, } from '../keybindings/index.js';
+import { BINDING_CATALOG, formatGesture, resolveUserKeybindings, } from '../keybindings/index.js';
 import { bundledPiCommandForShell } from './pi-cli.js';
 import { surfaceTmuxStyleArgs } from './surface-bg.js';
 import { inboxToggleTmuxCommand } from '@crouton-kit/humanloop';
@@ -470,7 +470,7 @@ export function sendKeysEnter(pane, text) {
 // ---------------------------------------------------------------------------
 const TMUX_BINDING_MANIFEST = '@crtr_keybindings_manifest';
 const ROOT_TABLE = 'root';
-const MENU_ACTIONS = {
+const LEAF_MENU_ACTIONS = {
     'crtr.tmux.menu.promote': { description: 'promote to orchestrator', action: { kind: 'keys', keys: '/promote' } },
     'crtr.tmux.menu.resume': { description: 'resume node', action: { kind: 'keys', keys: '/resume-node' } },
     'crtr.tmux.menu.fork': { description: 'fork into idle root', action: { kind: 'direct', run: 'node fork --pane {pane}' } },
@@ -484,7 +484,6 @@ const MENU_ACTIONS = {
     'crtr.tmux.menu.file-review': { description: 'review a file', action: { kind: 'raw-keys', keys: 'M-S-r' } },
     'crtr.tmux.menu.metadata': { description: 'metadata', action: { kind: 'keys', keys: '/node-metadata' } },
     'crtr.tmux.menu.fold-tools': { description: 'fold finished tool calls', action: { kind: 'keys', keys: '/fold-tools' } },
-    'crtr.tmux.menu.view-settings': undefined,
     'crtr.tmux.menu.context': { description: 'context + reports', action: { kind: 'keys', keys: '/context' } },
     'crtr.tmux.menu.providers': { description: 'settings', action: { kind: 'popup', run: 'sys setup' } },
     'crtr.tmux.menu.graph': { description: 'graph view', action: { kind: 'keys', keys: '/graph' } },
@@ -492,16 +491,8 @@ const MENU_ACTIONS = {
     'crtr.tmux.menu.copy-id': { description: 'copy node id', action: { kind: 'command', run: 'surface node id --pane {pane}' } },
     'crtr.tmux.menu.reload-viewer': { description: 'reload viewer', action: { kind: 'direct', run: 'surface reload --pane {pane}' } },
     'crtr.tmux.menu.pin': { description: 'pin conversation', action: { kind: 'direct', run: 'surface node pin --pane {pane}' } },
-    'crtr.tmux.menu.open': undefined,
-    'crtr.tmux.menu.show': undefined,
-    'crtr.tmux.menu.issues': undefined,
-    'crtr.tmux.menu.issue.idea': undefined,
-    'crtr.tmux.menu.issue.bug': undefined,
-    'crtr.tmux.node.next': undefined,
-    'crtr.tmux.node.previous': undefined,
-    'crtr.tmux.inbox.toggle': undefined,
-    'crtr.tmux.view.next': undefined,
-    'crtr.tmux.view.previous': undefined,
+    'crtr.tmux.menu.issue.idea': { description: 'idea', action: { kind: 'popup', run: 'canvas issue new --type idea' } },
+    'crtr.tmux.menu.issue.bug': { description: 'bug', action: { kind: 'popup', run: 'canvas issue new --type bug' } },
 };
 function escapeTmuxFormats(value) {
     return value.replace(/#/g, '##');
@@ -512,34 +503,69 @@ function tmuxCommand(args) {
 function chordCommand(run, interactive = false) {
     const command = `crtr canvas chord --pane '#{pane_id}' --run ${shellQuote(escapeTmuxFormats(run))}${interactive ? ' --interactive' : ''}`;
     return interactive
-        ? `display-popup -E -w 60% -h 50% -d "#{pane_current_path}" ${shellQuote(command)}`
-        : `run-shell ${shellQuote(`${command} >/dev/null 2>&1`)}`;
+        ? {
+            argv: ['display-popup', '-E', '-w', '60%', '-h', '50%', '-d', '#{pane_current_path}', command],
+            menu: `display-popup -E -w 60% -h 50% -d "#{pane_current_path}" ${shellQuote(command)}`,
+        }
+        : {
+            argv: ['run-shell', `${command} >/dev/null 2>&1`],
+            menu: `run-shell ${shellQuote(`${command} >/dev/null 2>&1`)}`,
+        };
 }
-/** Dispatch a menu action straight to a `crtr` invocation, skipping the
+/** Dispatch an action straight to a `crtr` invocation, skipping the
  *  `canvas chord` hop entirely. Only sound for an action whose sole
  *  interpolation need is `{pane}` — tmux expands it natively as `#{pane_id}` at
- *  selection time (a real tmux format, substituted AFTER escaping the static
+ *  keypress time (a real tmux format, substituted AFTER escaping the static
  *  run text so the `#` here is never doubled), so chord's node-resolution
- *  round trip buys nothing. `-b` keeps the menu selection non-blocking. */
+ *  round trip buys nothing. `-b` keeps dispatch non-blocking. */
 function directCommand(run) {
     const argv = escapeTmuxFormats(run).replace('{pane}', '#{pane_id}');
-    return `run-shell -b ${shellQuote(`crtr ${argv} >/dev/null 2>&1`)}`;
+    const command = `crtr ${argv} >/dev/null 2>&1`;
+    return {
+        argv: ['run-shell', '-b', command],
+        menu: `run-shell -b ${shellQuote(command)}`,
+    };
 }
-function renderMenuAction(action) {
+/** One command constructor serves both display-menu selections and direct root
+ *  shortcuts. Each result carries the argv bind-key needs plus the stable menu
+ *  serialization existing Alt+C installs already use. */
+function menuActionCommand(action) {
     switch (action.kind) {
-        case 'disabled': return '';
-        case 'separator': return '';
+        case 'disabled': return null;
+        case 'separator': return null;
         // Choosing any menu item closes it; refresh-client is the deliberately
         // inert command that lets the prefix shortcut choose this close row.
-        case 'dismiss': return 'refresh-client';
-        case 'keys': return `send-keys -t '#{pane_id}' ${shellQuote(escapeTmuxFormats(action.keys))} Enter`;
-        case 'raw-keys': return `send-keys -t '#{pane_id}' ${shellQuote(escapeTmuxFormats(action.keys))}`;
+        case 'dismiss': return { argv: ['refresh-client'], menu: 'refresh-client' };
+        case 'keys': {
+            const keys = escapeTmuxFormats(action.keys);
+            return {
+                // A root binding already runs in the pressed key's pane context. Its
+                // target must stay implicit: bind-key does not expand `#{pane_id}` in
+                // send-keys' target argument. A menu command is serialized later and
+                // does need the pane captured when the menu opened.
+                argv: ['send-keys', keys, 'Enter'],
+                menu: `send-keys -t '#{pane_id}' ${shellQuote(keys)} Enter`,
+            };
+        }
+        case 'raw-keys': {
+            const keys = escapeTmuxFormats(action.keys);
+            return {
+                argv: ['send-keys', keys],
+                menu: `send-keys -t '#{pane_id}' ${shellQuote(keys)}`,
+            };
+        }
         case 'command': return chordCommand(action.run);
         case 'direct': return directCommand(action.run);
         case 'popup': return chordCommand(action.run, true);
-        case 'submenu': return tmuxCommand(buildMenuArgs(action.title, action.items));
+        case 'submenu': {
+            const argv = buildMenuArgs(action.title, action.items);
+            return { argv, menu: tmuxCommand(argv) };
+        }
     }
 }
+function renderMenuAction(action) {
+    return menuActionCommand(action)?.menu ?? '';
+}
 /** Visible width of a menu item name: style markup (`#[...]`) takes no cells. */
 function menuItemWidth(description) {
     return description.replace(/#\[[^\]]*\]/g, '').length;
@@ -573,8 +599,12 @@ function tmuxKey(stroke) {
     let key = parts.pop();
     const modifiers = new Set(parts);
     if (modifiers.has('shift') && key.length === 1 && /[a-z]/.test(key)) {
+        // tmux names a shifted printable with its uppercase character even when an
+        // extended-key terminal also preserves Shift as a modifier: Alt+Shift+F is
+        // `M-S-F`. Shift by itself needs only the uppercase character (`F`).
         key = key.toUpperCase();
-        modifiers.delete('shift');
+        if (!modifiers.has('ctrl') && !modifiers.has('alt'))
+            modifiers.delete('shift');
     }
     key = TMUX_NAMED_KEYS[key] ?? key;
     const prefix = [
@@ -589,34 +619,56 @@ function menuSelector(stroke) {
     const key = parts.at(-1);
     return parts.includes('shift') && /[a-z]/.test(key) ? key.toUpperCase() : key === 'space' ? ' ' : key;
 }
-function menuItems(bindings) {
-    const boundItems = (ids) => {
-        const items = [];
-        for (const id of ids) {
-            const entry = MENU_ACTIONS[id];
-            if (entry === undefined)
-                continue;
-            for (const gesture of bindings.gestures(id)) {
-                items.push({ description: entry.description, selector: menuSelector(gesture), action: entry.action });
-            }
-        }
-        return items;
-    };
-    const issueItems = [];
-    for (const [id, description, type] of [
-        ['crtr.tmux.menu.issue.idea', 'idea', 'idea'],
-        ['crtr.tmux.menu.issue.bug', 'bug', 'bug'],
-    ]) {
+function boundMenuItems(ids, entries, bindings) {
+    const items = [];
+    for (const id of ids) {
+        const entry = entries.get(id);
+        if (entry === undefined)
+            continue;
         for (const gesture of bindings.gestures(id)) {
-            issueItems.push({ description, selector: menuSelector(gesture), action: { kind: 'popup', run: `canvas issue new --type ${type}` } });
+            items.push({ description: entry.description, selector: menuSelector(gesture), action: entry.action });
         }
     }
-    const lifecycleItems = boundItems([
-        'crtr.tmux.menu.promote',
-        'crtr.tmux.menu.demote',
-        'crtr.tmux.menu.detach',
-        'crtr.tmux.menu.close-subtree',
-    ]);
+    return items;
+}
+/** Resolve the complete action descriptor set once. Submenu openers point at
+ *  the same child MenuItems the prefix menu renders, so their direct global
+ *  shortcuts cannot drift from the menu path. */
+function resolvedMenuActions(bindings) {
+    const entries = new Map();
+    for (const [id, entry] of Object.entries(LEAF_MENU_ACTIONS)) {
+        if (entry !== undefined)
+            entries.set(id, entry);
+    }
+    const showItems = boundMenuItems([
+        'crtr.tmux.menu.metadata',
+        'crtr.tmux.menu.context',
+    ], entries, bindings);
+    entries.set('crtr.tmux.menu.show', {
+        description: 'show ›',
+        action: { kind: 'submenu', title: ' show node ', items: showItems },
+    });
+    // How this viewer PAINTS the transcript, as opposed to what it shows. Each item
+    // is a toggle the viewer applies to its own render state (a `/`-command sent to
+    // the pane); a tmux menu is built once and cannot show live state, so the item
+    // reads as the action and the viewer answers with a notice.
+    const viewSettingsItems = boundMenuItems(['crtr.tmux.menu.fold-tools'], entries, bindings);
+    entries.set('crtr.tmux.menu.view-settings', {
+        description: 'view settings ›',
+        action: { kind: 'submenu', title: ' view settings ', items: viewSettingsItems },
+    });
+    const issueItems = boundMenuItems([
+        'crtr.tmux.menu.issue.idea',
+        'crtr.tmux.menu.issue.bug',
+    ], entries, bindings);
+    entries.set('crtr.tmux.menu.issues', {
+        description: 'create ›',
+        action: { kind: 'submenu', title: ' create ', items: issueItems },
+    });
+    return entries;
+}
+function menuItems(bindings, entries) {
+    const boundItems = (ids) => boundMenuItems(ids, entries, bindings);
     const items = [];
     const addGroup = (heading, groupItems) => {
         if (groupItems.length === 0)
@@ -625,41 +677,15 @@ function menuItems(bindings) {
             items.push({ description: '', selector: '', action: { kind: 'separator' } });
         items.push({ description: `-#[bold]${heading}`, selector: '', action: { kind: 'disabled' } }, ...groupItems);
     };
-    const showItems = boundItems([
-        'crtr.tmux.menu.metadata',
-        'crtr.tmux.menu.context',
-    ]);
-    // How this viewer PAINTS the transcript, as opposed to what it shows. Each item
-    // is a toggle the viewer applies to its own render state (a `/`-command sent to
-    // the pane); a tmux menu is built once and cannot show live state, so the item
-    // reads as the action and the viewer answers with a notice.
-    const viewSettingsItems = boundItems(['crtr.tmux.menu.fold-tools']);
-    const exploreItems = boundItems([
+    // Explore changes what is in view or opens a canvas-level browser. Current
+    // node acts on the agent in this pane without changing its lifecycle.
+    addGroup('Explore', boundItems([
         'crtr.tmux.menu.resume',
         'crtr.tmux.menu.graph',
         'crtr.tmux.menu.focus-manager',
-    ]);
-    if (showItems.length > 0) {
-        for (const gesture of bindings.gestures('crtr.tmux.menu.show')) {
-            exploreItems.push({
-                description: 'show ›',
-                selector: menuSelector(gesture),
-                action: { kind: 'submenu', title: ' show node ', items: showItems },
-            });
-        }
-    }
-    if (viewSettingsItems.length > 0) {
-        for (const gesture of bindings.gestures('crtr.tmux.menu.view-settings')) {
-            exploreItems.push({
-                description: 'view settings ›',
-                selector: menuSelector(gesture),
-                action: { kind: 'submenu', title: ' view settings ', items: viewSettingsItems },
-            });
-        }
-    }
-    // Explore changes what is in view or opens a canvas-level browser. Current
-    // node acts on the agent in this pane without changing its lifecycle.
-    addGroup('Explore', exploreItems);
+        'crtr.tmux.menu.show',
+        'crtr.tmux.menu.view-settings',
+    ]));
     addGroup('Current node', boundItems([
         'crtr.tmux.menu.background-bash',
         'crtr.tmux.menu.file-review',
@@ -667,21 +693,17 @@ function menuItems(bindings) {
         'crtr.tmux.menu.copy-id',
         'crtr.tmux.menu.reload-viewer',
     ]));
-    addGroup('Lifecycle', [
-        ...boundItems(['crtr.tmux.menu.fork']),
-        ...lifecycleItems,
-    ]);
-    const systemItems = boundItems(['crtr.tmux.menu.providers']);
-    if (issueItems.length > 0) {
-        for (const gesture of bindings.gestures('crtr.tmux.menu.issues')) {
-            systemItems.push({
-                description: 'create ›',
-                selector: menuSelector(gesture),
-                action: { kind: 'submenu', title: ' create ', items: issueItems },
-            });
-        }
-    }
-    addGroup('System', systemItems);
+    addGroup('Lifecycle', boundItems([
+        'crtr.tmux.menu.fork',
+        'crtr.tmux.menu.promote',
+        'crtr.tmux.menu.demote',
+        'crtr.tmux.menu.detach',
+        'crtr.tmux.menu.close-subtree',
+    ]));
+    addGroup('System', boundItems([
+        'crtr.tmux.menu.providers',
+        'crtr.tmux.menu.issues',
+    ]));
     const prefixGestures = bindings.gestures('crtr.tmux.menu.open');
     if (prefixGestures.length > 0 && items.length > 0) {
         items.push({ description: '', selector: '', action: { kind: 'separator' } });
@@ -835,10 +857,24 @@ export function installTmuxBindings(bindings = resolveUserKeybindings()) {
         installed.push({ table, key });
         return true;
     };
-    const menuCommand = buildMenuArgs(' crtr ', menuItems(bindings));
+    const menuActions = resolvedMenuActions(bindings);
+    const menuCommand = buildMenuArgs(' crtr ', menuItems(bindings, menuActions));
     for (const gesture of bindings.gestures('crtr.tmux.menu.open')) {
         install(ROOT_TABLE, tmuxKey(gesture), menuCommand, 'crtr.tmux.menu.open', gesture);
     }
+    for (const definition of BINDING_CATALOG) {
+        if (definition.pair?.field !== 'menu')
+            continue;
+        const menuId = definition.id;
+        const globalId = definition.pair.pairedId;
+        const entry = menuActions.get(menuId);
+        const command = entry === undefined ? null : menuActionCommand(entry.action);
+        if (command === null)
+            throw new Error(`no direct tmux action for paired menu binding ${menuId}`);
+        for (const gesture of bindings.gestures(globalId)) {
+            install(ROOT_TABLE, tmuxKey(gesture), command.argv, globalId, gesture);
+        }
+    }
     for (const id of ['crtr.tmux.node.next', 'crtr.tmux.node.previous', 'crtr.tmux.inbox.toggle']) {
         for (const gesture of bindings.gestures(id))
             install(ROOT_TABLE, tmuxKey(gesture), actionCommand(id), id, gesture);

package/dist/core/scope.js

@@ -87,11 +87,10 @@ export function findProjectScopeRoot(startDir = process.cwd()) {
  *  nested under a directory tree that itself contains a `.crouter/` (e.g. a
  *  mock-VM home under the real host home) would sweep the host's `~/.crouter`
  *  (and any other above-HOME `.crouter`) in as a bogus project ancestor,
- *  leaking one machine's user-global memory into a nested-HOME node. Mirrors
- *  the on-read positional-walk fence (src/core/substrate/on-read.ts). A read
- *  whose start dir is outside HOME (e.g. a production VM with HOME=/root and no
- *  ancestor `.crouter`) never reaches home and walks to the filesystem root, as
- *  before. */
+ *  leaking one machine's user-global memory into a nested-HOME node. The
+ *  explicit file-context store discovery in substrate/on-read.ts applies the
+ *  same fence. A read whose start dir is outside HOME (e.g. a production VM
+ *  with HOME=/root and no ancestor `.crouter`) walks to the filesystem root. */
 function collectAncestorScopeRoots(startDir, userRoot) {
     const roots = [];
     const home = realpathOrSelf(homedir());

package/dist/core/substrate/ceiling.d.ts

@@ -8,13 +8,10 @@ export declare function isIndexName(name: string): boolean;
 export declare function indexDirOf(name: string): string;
 /** Returns the display path corresponding to a canonical logical identifier. */
 export declare function displayName(name: string): string;
-/** The two visibility surfaces an INDEX can cap. */
-export type Surface = 'systemPromptVisibility' | 'fileReadVisibility';
 /** Build the dir → governing-INDEX map. Precedence is first-occurrence-wins, so
  *  callers MUST pass docs precedence-ordered (project > user > builtin) — the
  *  highest-precedence INDEX governs a dir, mirroring the memory resolver. */
 export declare function buildCeilingIndex(docs: SubstrateDoc[]): Map<string, SubstrateDoc>;
-/** A doc's effective rung on `surface` after applying every ancestor INDEX
- *  ceiling: min(own rung, each ancestor INDEX's rung). A `none` ancestor INDEX
- *  hides the whole subtree (min with none = none). */
-export declare function effectiveRung(doc: SubstrateDoc, ceil: Map<string, SubstrateDoc>, surface: Surface): Rung;
+/** A doc's effective system-prompt rung after applying every ancestor INDEX
+ * ceiling. A `none` ancestor hides the whole subtree from the boot catalog. */
+export declare function effectiveSystemPromptRung(doc: SubstrateDoc, ceil: Map<string, SubstrateDoc>): Rung;

package/dist/core/substrate/ceiling.js

@@ -1,16 +1,15 @@
-// ceiling.ts — canonical INDEX identifiers and the subtree rung ceiling.
+// ceiling.ts — canonical INDEX identifiers and the boot-catalog subtree ceiling.
 //
-// A directory index has the canonical logical identifier `<directory>/INDEX`
-// (`INDEX` at the root) and the same substrate frontmatter as any doc. Its rung
-// is a ceiling for every document in its subtree.
+// A directory INDEX has the canonical logical identifier `<directory>/INDEX`
+// (`INDEX` at the root). Its system-prompt rung caps every document in that
+// subtree while the boot catalog renders:
 //
 //   effective rung of a descendant = min(own rung, every ancestor INDEX's rung)
 //
-// So a directory's INDEX at `preview` lets its files surface at most at
-// `preview`; an INDEX at `none` hides the whole subtree. This is the single,
-// explicit mechanism for collapsing a directory in agent-facing surfaces (boot
-// render + on-read) — there is no parallel auto-hiding heuristic. See design
-// taste: `crtr memory read taste/document-substrate`.
+// A `preview` INDEX therefore lets its descendants surface at most at preview;
+// a `none` INDEX hides the subtree. File context does not use this ceiling:
+// every workspace/file match is an explicit `applies-to` route and renders at
+// the matched document's own file-read rung.
 import { rungRank } from './schema.js';
 /** The reserved basename (no extension) that marks a directory's index doc. */
 export const INDEX_NAME = 'INDEX';
@@ -55,15 +54,14 @@ function ancestorDirs(name) {
         out.push(parts.slice(0, i).join('/'));
     return out;
 }
-/** A doc's effective rung on `surface` after applying every ancestor INDEX
- *  ceiling: min(own rung, each ancestor INDEX's rung). A `none` ancestor INDEX
- *  hides the whole subtree (min with none = none). */
-export function effectiveRung(doc, ceil, surface) {
-    let rung = doc[surface];
+/** A doc's effective system-prompt rung after applying every ancestor INDEX
+ * ceiling. A `none` ancestor hides the whole subtree from the boot catalog. */
+export function effectiveSystemPromptRung(doc, ceil) {
+    let rung = doc.systemPromptVisibility;
     for (const dir of ancestorDirs(doc.name)) {
         const idx = ceil.get(dir);
         if (idx)
-            rung = minRung(rung, idx[surface]);
+            rung = minRung(rung, idx.systemPromptVisibility);
     }
     return rung;
 }

package/dist/core/substrate/index.d.ts

@@ -4,8 +4,7 @@ export { scopeForCwd, profileNameFor } from './subject-fields.js';
 export type { NodeConfigSubject } from './subject-fields.js';
 export { spineDepth, assembleNodeSubject } from './subject.js';
 export { gatePasses } from './gate.js';
-export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveRung, } from './ceiling.js';
-export type { Surface } from './ceiling.js';
+export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveSystemPromptRung, } from './ceiling.js';
 export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocs } from './on-read.js';
+export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read.js';

package/dist/core/substrate/index.js

@@ -19,7 +19,7 @@ resolveDocName, } from './schema.js';
 export { scopeForCwd, profileNameFor } from './subject-fields.js';
 export { spineDepth, assembleNodeSubject } from './subject.js';
 export { gatePasses } from './gate.js';
-export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveRung, } from './ceiling.js';
+export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveSystemPromptRung, } from './ceiling.js';
 export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocs } from './on-read.js';
+export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read.js';

package/dist/core/substrate/on-read.d.ts

@@ -1,14 +1,5 @@
-/**
- * Render the substrate docs that should surface alongside a just-read file.
- *
- * @param nodeId        the canvas node whose subject gates the docs.
- * @param readFilePath  the path the `read` tool returned (absolute or not — it
- *                      is resolved to a realpath internally).
- * @param seen          the CALLER-owned, per-session set of already-injected
- *                      doc realpaths. Docs already present are skipped; newly
- *                      injected docs are added. Pass the same set across reads
- *                      within a session (clear it on session_start) to get the
- *                      once-per-session dedup; omit it for a standalone render.
- * @returns the `<auto-loaded-context>` envelope, or '' when nothing surfaces.
- */
+/** Surface docs matched by a successful read tool call. */
 export declare function renderOnReadDocs(nodeId: string, readFilePath: string, seen?: Set<string>): string;
+/** Surface workspace-wide docs during first-message assembly. `.` is a reserved
+ * applies-to target meaning “when this project store is mounted by cwd/profile”. */
+export declare function renderWorkspaceOpenDocs(nodeId: string): string;