@north-light/crouter 0.3.220 → 0.3.222

package/dist/builtin-memory/spec/guide.md

@@ -1,21 +1,38 @@
 ---
 kind: knowledge
-when-and-why-to-read: When eliciting or writing a specification, this knowledge should be read because downstream design and planning need settled intent without making the user answer avoidable questions or forcing every request through the same ceremony.
-short-form: Elicit only consequential uncertainty, then write a right-sized behavioral contract a downstream reader can use without guessing.
-rationale: Specification quality and elicitation guidance lived inside an always-loaded spec persona while the lightweight /spec command had almost none, leaving agents to choose between a vague one-shot and a fixed discovery workflow.
+when-and-why-to-read: When exploring, eliciting, or writing a specification, this knowledge should be read because the outcome has to be developed with the user before it is pinned down, and downstream design and planning then need it settled without avoidable questions or ceremony.
+short-form: Explore openly with the user, converge on what they chose, then write a right-sized behavioral contract a downstream reader can use without guessing.
+rationale: >-
+  Specification quality and elicitation guidance lived inside an always-loaded spec persona while the lightweight /spec command had almost none, leaving agents to choose between a vague one-shot and a fixed discovery workflow. Spec writers also promoted plausible nice-to-haves into requirements without asking, silently expanding the requested work. Every remaining lever then pointed at convergence — one interpretation reflected back, questions minimized, elicitation stopped as soon as no answer would change the contract — so the agent transcribed the request instead of developing it. The exploration is about the solution — challenging the user's premise is available when something genuinely does not fit, never a required move.
 ---
 
 # Writing a specification
 
 A specification settles **what outcome and behavior are required**. It is not an architecture document or an implementation plan. Its depth follows the stakes and unresolved intent: a small reversible change may need a few paragraphs; a consequential product surface may need collaborative discovery and separate design.
 
+## Explore before you converge
+
+Take the request at face value and put the openness into what it could be. Understand what the user is trying to achieve and why now, then develop the possibilities with them: a specification is the output of a finished exploration, and the first shape anyone thinks of is rarely the best one available.
+
+Develop a few genuinely different directions rather than enumerating shallow variants, and push each one several steps — what changes, what that makes possible next, what it looks like once it exists. Moves that open a direction: remove a constraint everyone assumed; change who or what is served; do materially less than asked and see what survives; ask what happens if nothing changes at all. Where the surrounding system or prior art would feed the thinking, read for it while you think, not as a validation pass afterward.
+
+Bring these to the user as live options, in plain language, with what each buys and closes off. Do not open with objections, feasibility verdicts, or a recommendation, and do not pre-reject an unusual but coherent direction — nothing is committed until the user picks, so divergence is free. If something in the request genuinely does not fit what they are trying to achieve, say so once; questioning their premise is not the job.
+
+Converge when the user has chosen among live options and what remains is detail.
+
 ## Elicit without interrogating
 
-Investigate before asking. Read the request, relevant code and documents, and already-settled decisions first. A fact available from the project is not a question for the user.
+Investigate before asking. Read the request, relevant code and documents, and already-settled decisions first. A fact available from the project is not a question for the user; intent never is such a fact.
+
+Reflect a concrete interpretation back so the user can confirm or correct it. Resolve the uncertainty whose answer could most change behavior, scope, or acceptance. When a decision really belongs to the user, give them a focused question with a proposed default or concrete options; use one decision or one small coherent set rather than a questionnaire.
+
+Spend attention where judgment is load-bearing, not where detail is merely available. Keep settled points moving and fold each answer into the specification as current truth. Once converged, stop eliciting when another answer would not materially change the behavioral contract. Explicit approval is warranted when the user is co-authoring the document or the remaining decision is consequential; ordinary reversible work does not need a ritual approval loop.
+
+## Commit only what the user chose
 
-Reflect a concrete interpretation of the request so the user can confirm or correct it. Resolve the uncertainty whose answer could most change behavior, scope, or acceptance. When a decision really belongs to the user, give them a focused question with a proposed default or concrete options; use one decision or one small coherent set rather than a questionnaire.
+Exploration is unbounded; the document is not. What you explored and the user did not choose stays out — speculative features, future extensibility, adjacent cleanup, and other merely plausible additions are not requirements just because they came up. The bar is not smallness for its own sake: nothing enters the specification without the user's assent.
 
-Spend attention where judgment is load-bearing, not where detail is merely available. Keep settled points moving and fold each answer into the specification as current truth. Stop eliciting when another answer would not materially change the behavioral contract. Explicit approval is warranted when the user is co-authoring the document or the remaining decision is consequential; ordinary reversible work does not need a ritual approval loop.
+When something seems likely desirable but is not explicitly or implicitly required by the request, ask the user whether to include it through `crtr human` before finishing the specification (`crtr human send -h`), wait for their answer, and make the resulting boundary explicit. Do not hide the addition in an assumption, recommendation, or optional requirement.
 
 ## The finished specification
 

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/claude-plugin-commands.ts

@@ -164,7 +164,7 @@ function selectedProfileProjects(): string[] {
   const profileId = process.env["CRTR_PROFILE_ID"] ?? "";
   if (profileId === "") return [];
   try {
-    return loadProfileManifest(profileId).manifest.projects;
+    return loadProfileManifest(profileId).manifest.projects.map((project) => project.path);
   } catch {
     // A deleted or invalid selected profile must not hide cwd-local commands.
     return [];

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/crtr-commands/index.ts

@@ -4,6 +4,7 @@ import { promisify } from "node:util";
 import { readFileSync, existsSync, realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, join } from "node:path";
+import type { ChatCommandMetadata } from "../../../../core/runtime/command-surface.js";
 
 const exec = promisify(execFile);
 
@@ -149,6 +150,11 @@ export default async function (pi: ExtensionAPI) {
     const invocation = `Run \`crtr ${path.join(" ")} -h\` (pass args to run the real command)`;
     pi.registerCommand(name, {
       description: node.description ? `${node.description} — ${invocation}` : invocation,
+      // Chat-capable: the handler's outcome is the command's output placed into
+      // the conversation as a displayed message. The transient status line is
+      // decoration a surface without one simply does not show.
+      gateway: true as const,
+      argumentHint: "[args]",
       handler: async (args, ctx) => {
         const extra = (args ?? "").trim();
         // No args -> show help. With args -> run the real command.
@@ -165,7 +171,7 @@ export default async function (pi: ExtensionAPI) {
           { triggerTurn: TRIGGER_TURN },
         );
       },
-    });
+    } as Parameters<ExtensionAPI["registerCommand"]>[1] & ChatCommandMetadata);
   };
 
   const filters = loadFilters();

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/memory-slash-commands.ts

@@ -6,6 +6,7 @@ import {
   type DeterministicCommandExpansion,
 } from "../../../core/runtime/command-expansion.js";
 import { expandShellBlocks, hasShellBlocks, DEFAULT_SHELL_TIMEOUT_MS } from "../../../core/runtime/shell-expansion.js";
+import type { ChatCommandMetadata } from "../../../core/runtime/command-surface.js";
 import { piShellRunner } from "./pi-shell-runner.js";
 
 // ---------------------------------------------------------------------------
@@ -43,10 +44,9 @@ export interface SlashDoc {
   description: string;
 }
 
-// `memory list` already chose the winning path for each identity. Keep that
-// path for registration-body reads so every slash document does not re-walk the
-// full corpus through `memory read`.
-const resolvedMemoryPaths = new Map<string, string>();
+// `memory list` already chose each winning document. Keep its canonical body
+// for disclosure classification and its path for the existing execution read.
+const resolvedMemoryDocs = new Map<string, { path: string; canonicalBody: string }>();
 
 async function defaultListMemoryDocs(): Promise<MemoryListItem[]> {
   const snapshot = createMemoryDocSnapshot();
@@ -67,15 +67,24 @@ async function defaultListMemoryDocs(): Promise<MemoryListItem[]> {
     return item.slash === true ? [item.name] : [];
   });
   const resolved = snapshot.resolve(names);
-  resolvedMemoryPaths.clear();
-  for (const [name, doc] of resolved) resolvedMemoryPaths.set(name, doc.path);
+  resolvedMemoryDocs.clear();
+  for (const [name, doc] of resolved) {
+    resolvedMemoryDocs.set(name, { path: doc.path, canonicalBody: doc.body });
+  }
   return items;
 }
 
-function defaultReadMemoryDoc(name: string): string {
-  const path = resolvedMemoryPaths.get(name);
-  if (path === undefined) throw new Error(`memory slash document was not resolved: ${name}`);
-  return readMemoryDocContent(path);
+function defaultReadMemoryDoc(name: string): { canonicalBody: string; executionBody: string } {
+  const resolved = resolvedMemoryDocs.get(name);
+  if (resolved === undefined) throw new Error(`memory slash document was not resolved: ${name}`);
+  return {
+    canonicalBody: resolved.canonicalBody,
+    executionBody: readMemoryDocContent(resolved.path),
+  };
+}
+
+function hasNodeRelativeExpansion(body: string): boolean {
+  return body.includes("$CRTR_CONTEXT_DIR") || body.includes("$CRTR_NODE_ID");
 }
 
 /** `/`-joined path-derived doc name -> the registered slash-command name. */
@@ -109,24 +118,33 @@ export default async function (pi: ExtensionAPI) {
   const docs = await discoverSlashDocs();
   for (const doc of docs) {
     let expansion: DeterministicCommandExpansion | undefined;
+    let discloseExpansion = false;
     let loadError: unknown;
     try {
+      const body = defaultReadMemoryDoc(doc.name);
       expansion = {
         kind: "memory-slash",
         commandName: doc.commandName,
-        body: defaultReadMemoryDoc(doc.name),
+        body: body.executionBody,
       };
+      discloseExpansion = !hasNodeRelativeExpansion(body.canonicalBody);
     } catch (err) {
       loadError = err;
     }
 
     // pi preserves unknown registration fields on the resolved command object.
-    // The broker discloses this serializable contract through get_commands; the
-    // handler below consumes the SAME object and expander, so preview cannot
-    // drift from submission. A failed/dynamic command has no expansion metadata.
+    // The broker discloses deterministic expansions through get_commands. A
+    // node-relative body still executes through the private expansion below,
+    // but cannot promise a concrete payload before the future node exists.
     pi.registerCommand(doc.commandName, {
       description: doc.description,
-      ...(expansion === undefined ? {} : { expansion }),
+      // Chat-capable: the handler's whole outcome is a conversation turn
+      // carrying the expanded document, which any surface hosting the
+      // conversation receives. Only when the expansion loaded — without it the
+      // sole outcome is a terminal-only error notify, so it stays undisclosed.
+      ...(expansion === undefined
+        ? {}
+        : { gateway: true as const, ...(discloseExpansion ? { expansion } : {}) }),
       handler: async (args, ctx) => {
         if (expansion === undefined) {
           ctx.ui.notify(
@@ -157,6 +175,6 @@ export default async function (pi: ExtensionAPI) {
           { triggerTurn: true },
         );
       },
-    } as Parameters<ExtensionAPI["registerCommand"]>[1] & { expansion?: DeterministicCommandExpansion });
+    } as Parameters<ExtensionAPI["registerCommand"]>[1] & { expansion?: DeterministicCommandExpansion } & ChatCommandMetadata);
   }
 }

package/dist/clients/attach/__tests__/ref-autocomplete.test.js

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import { findRefCompletionContext, RefAwareAutocompleteProvider } from '../input/ref-autocomplete.js';
 function ref(name, shortForm = `${name} docs`) {
-    return { name, kind: 'knowledge', scope: 'user', shortForm };
+    return { name, kind: 'knowledge', scope: 'user', shortForm, gatewayVisible: true };
 }
 /** The wrapped provider; ref handling must never reach it in a ref context. */
 const inertDelegate = {

package/dist/clients/attach/__tests__/titled-editor-preview.test.js

@@ -47,7 +47,7 @@ test('Enter-confirming a non-leading ref completion accepts the token and return
     editor.onSubmit = (text) => {
         submitted = text;
     };
-    const refs = [{ name: 'dev', kind: 'knowledge', scope: 'user', shortForm: 'dev docs' }];
+    const refs = [{ name: 'dev', kind: 'knowledge', scope: 'user', shortForm: 'dev docs', gatewayVisible: true }];
     const delegate = {
         async getSuggestions() {
             return null;

package/dist/clients/attach/overlays/file-review.js

@@ -2,7 +2,7 @@ import { homedir } from 'node:os';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { Input, SelectList, getKeybindings, } from '@earendil-works/pi-tui';
 import { getSelectListTheme } from '@earendil-works/pi-coding-agent';
-import { openReviewSurface } from '../../inbox/review/launch.js';
+import { openReviewWindow } from '../../inbox/review/launch.js';
 import { createReviewClient, ReviewTerminalError, terminalRefusalNotice } from '../../inbox/review/review-client.js';
 import { checkReviewableFile, extractFilePaths } from '#core/human/visible-paths';
 const MAX_VISIBLE_ROWS = 12;
@@ -123,6 +123,6 @@ export async function launchFileReview(host, file, opts) {
         opts.onNotice(err instanceof ReviewTerminalError ? terminalRefusalNotice(err) : err instanceof Error ? err.message : String(err));
         return;
     }
-    await openReviewSurface(host, { review });
+    openReviewWindow(host, review);
 }
 export { extractFilePaths };

package/dist/clients/attach/render/markdown-source.js

@@ -22,6 +22,7 @@
 // GLYPHS. Private-use `U+XXXX` references become their glyphs (see
 // glyph-codepoints.ts), so an agent that cannot type a Nerd Font character can
 // still put one on screen.
+import { pathToFileURL } from 'node:url';
 import { expandGlyphCodepoints } from './glyph-codepoints.js';
 const ATX_HEADING = /^(\s{0,3})(#{3,6})(?:[ \t]+|$)(.*?)([ \t]+#+[ \t]*)?$/;
 const FENCE_OPEN = /^\s{0,3}(`{3,}|~{3,})/;
@@ -126,7 +127,111 @@ export function styleAttachMarkdownSource(markdown) {
  *  message keeps `styleAttachMarkdownSource` alone — the `U+XXXX` escape hatch
  *  exists for agents that cannot type a Nerd Font character. */
 export function styleAttachAgentMarkdown(markdown) {
-    return expandGlyphCodepoints(styleAttachMarkdownSource(markdown));
+    return expandGlyphCodepoints(styleAttachMarkdownSource(rewriteAbsoluteFileLinks(markdown)));
+}
+/** Give iTerm a hidden fragment so its Semantic History action receives the local target. */
+function rewriteAbsoluteFileLinks(markdown) {
+    let fence;
+    return markdown.split('\n').map((line) => {
+        const fenceMatch = FENCE_OPEN.exec(line);
+        if (fence !== undefined) {
+            if (fenceMatch?.[1][0] === fence)
+                fence = undefined;
+            return line;
+        }
+        if (fenceMatch) {
+            fence = fenceMatch[1][0];
+            return line;
+        }
+        return rewriteInlineFileLinks(line);
+    }).join('\n');
+}
+function rewriteInlineFileLinks(line) {
+    let result = '';
+    let rest = line;
+    while (rest !== '') {
+        const opening = rest.match(/`+/);
+        const prose = opening === null ? rest : rest.slice(0, opening.index);
+        result += rewriteProseFileLinks(prose);
+        if (opening === null)
+            break;
+        const delimiter = opening[0];
+        const end = rest.indexOf(delimiter, prose.length + delimiter.length);
+        if (end === -1)
+            return result + rest.slice(prose.length);
+        result += rest.slice(prose.length, end + delimiter.length);
+        rest = rest.slice(end + delimiter.length);
+    }
+    return result;
+}
+function rewriteProseFileLinks(prose) {
+    let result = '';
+    let index = 0;
+    while (index < prose.length) {
+        const start = prose.indexOf('[', index);
+        if (start === -1)
+            return result + prose.slice(index);
+        const link = parseLocalMarkdownLink(prose, start);
+        if (link === undefined) {
+            result += prose.slice(index, start + 1);
+            index = start + 1;
+            continue;
+        }
+        result += prose.slice(index, start) + `[${link.label}](${pathToFileURL(link.path).href}#crtr-file-open)`;
+        index = link.end;
+    }
+    return result;
+}
+function parseLocalMarkdownLink(line, start) {
+    const labelEnd = closingDelimiter(line, start + 1, ']');
+    if (labelEnd === undefined || line[labelEnd + 1] !== '(')
+        return undefined;
+    const destinationStart = labelEnd + 2;
+    if (line[destinationStart] === '<') {
+        const destinationEnd = closingDelimiter(line, destinationStart + 1, '>');
+        if (destinationEnd === undefined || line[destinationEnd + 1] !== ')')
+            return undefined;
+        const path = localPathFromDestination(line.slice(destinationStart + 1, destinationEnd));
+        return path === undefined ? undefined : { label: line.slice(start + 1, labelEnd), path, end: destinationEnd + 2 };
+    }
+    let depth = 0;
+    for (let index = destinationStart; index < line.length; index++) {
+        if (line[index] === '\\') {
+            index++;
+            continue;
+        }
+        if (line[index] === '(') {
+            depth++;
+            continue;
+        }
+        if (line[index] !== ')' || depth-- > 0)
+            continue;
+        const path = localPathFromDestination(line.slice(destinationStart, index));
+        return path === undefined ? undefined : { label: line.slice(start + 1, labelEnd), path, end: index + 1 };
+    }
+    return undefined;
+}
+function closingDelimiter(text, start, delimiter) {
+    for (let index = start; index < text.length; index++) {
+        if (text[index] === '\\') {
+            index++;
+            continue;
+        }
+        if (text[index] === delimiter)
+            return index;
+    }
+    return undefined;
+}
+function localPathFromDestination(destination) {
+    const unescaped = destination.replace(/\\([!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-])/g, '$1');
+    let path = unescaped;
+    try {
+        path = decodeURIComponent(unescaped);
+    }
+    catch {
+        // A literal percent is legal in a path but not in URI decoding.
+    }
+    return path.startsWith('/') ? path : undefined;
 }
 /** Copy a pi message for terminal rendering and decorate only Markdown-bearing
  * text/thinking blocks. The broker's source event is never mutated. */

package/dist/clients/attach/session/file-links.d.ts

@@ -1,9 +1,18 @@
-/** URI of the OSC-8 hyperlink occupying the given 1-indexed terminal cell. */
-export declare function osc8UriAt(frame: readonly string[], row: number, column: number): string | undefined;
-export type LinkedFileOpenResult = 'opened' | 'missing' | 'invalid' | 'failed';
+/** A local file requested through iTerm Semantic History. */
+export interface FileOpenInput {
+    file: string | undefined;
+    remaining: string;
+}
+/**
+ * Strip the private iTerm Semantic History input and return its local path.
+ * iTerm expands `\\1` as a shell-escaped word, so decode that representation
+ * without ever evaluating it as shell input.
+ */
+export declare function extractFileOpenInput(data: string): FileOpenInput | undefined;
+export type LinkedFileOpenResult = 'opened' | 'missing' | 'failed';
 /** Replace this local viewer pane with Neovim, then reattach it when Neovim exits. */
 export declare function openLinkedFileInPane(opts: {
-    uri: string;
+    file: string;
     pane: string;
     cwd: string;
     nodeId: string;

package/dist/clients/attach/session/file-links.js

@@ -1,72 +1,68 @@
-// session/file-links.ts — OSC-8 file links in the rendered attach frame.
+// session/file-links.ts — iTerm Semantic History file-open bridge.
 //
-// A click is resolved against the physical rows last handed to the terminal,
-// not against transcript records: wrapping, fixed cockpit rows, ANSI styling,
-// and OSC-8 boundaries have all already been composed there.
+// iTerm sends the clicked path through a private input sequence. The viewer
+// validates it, replaces its pane with Neovim, then reattaches after exit.
 import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { walkRow } from '../ansi-cells.js';
 import { respawnPaneInBackground, shellQuote, viewerSplitEnv } from '../../../core/runtime/placement-tmux.js';
-/** URI of the OSC-8 hyperlink occupying the given 1-indexed terminal cell. */
-export function osc8UriAt(frame, row, column) {
-    if (!Number.isInteger(row) || !Number.isInteger(column) || row < 1 || column < 1)
+const FILE_OPEN_PREFIX = '\x1b_crtr-file-open;';
+const STRING_TERMINATOR = '\x1b\\';
+/**
+ * Strip the private iTerm Semantic History input and return its local path.
+ * iTerm expands `\\1` as a shell-escaped word, so decode that representation
+ * without ever evaluating it as shell input.
+ */
+export function extractFileOpenInput(data) {
+    const start = data.indexOf(FILE_OPEN_PREFIX);
+    if (start === -1)
         return undefined;
-    let activeUri;
-    for (let index = 0; index < Math.min(row, frame.length); index++) {
-        const hitColumn = index === row - 1 ? column : undefined;
-        const scanned = scanOsc8Row(frame[index] ?? '', activeUri, hitColumn);
-        activeUri = scanned.activeUri;
-        if (scanned.uri !== undefined)
-            return scanned.uri;
-    }
-    return undefined;
+    const pathStart = start + FILE_OPEN_PREFIX.length;
+    const end = data.indexOf(STRING_TERMINATOR, pathStart);
+    if (end === -1)
+        return undefined;
+    const file = decodeShellEscapedPath(data.slice(pathStart, end));
+    return { file, remaining: data.slice(0, start) + data.slice(end + STRING_TERMINATOR.length) };
 }
-function scanOsc8Row(line, initialUri, hitColumn) {
-    let activeUri = initialUri;
-    let uri;
-    walkRow(line, {
-        onEscape: (escape) => {
-            const osc8 = parseOsc8(escape);
-            if (osc8 !== null)
-                activeUri = osc8 === '' ? undefined : osc8;
-        },
-        onGlyph: (glyph) => {
-            if (uri !== undefined || hitColumn === undefined || activeUri === undefined || glyph.width === 0)
-                return;
-            const cell = hitColumn - 1;
-            if (cell >= glyph.cell && cell < glyph.cell + glyph.width)
-                uri = activeUri;
-        },
-    });
-    return { activeUri, uri };
+function decodeShellEscapedPath(value) {
+    const decoded = value.startsWith("'") ? decodeSingleQuotedPath(value) : decodeBackslashPath(value);
+    return decoded !== undefined && decoded.startsWith('/') && !/[\x00-\x1f\x7f]/.test(decoded) ? decoded : undefined;
 }
-/** `null` means another escape sequence; an empty URI closes the active link. */
-function parseOsc8(sequence) {
-    if (!sequence.startsWith('\x1b]8;'))
-        return null;
-    const terminatorLength = sequence.endsWith('\x1b\\') ? 2 : 1;
-    const body = sequence.slice(4, -terminatorLength);
-    const separator = body.indexOf(';');
-    if (separator === -1)
-        return null;
-    return body.slice(separator + 1);
+function decodeSingleQuotedPath(value) {
+    let result = '';
+    let index = 1;
+    while (true) {
+        const end = value.indexOf("'", index);
+        if (end === -1)
+            return undefined;
+        result += value.slice(index, end);
+        index = end + 1;
+        if (index === value.length)
+            return result;
+        if (value.slice(index, index + 3) !== "\\''")
+            return undefined;
+        result += "'";
+        index += 3;
+    }
+}
+function decodeBackslashPath(value) {
+    let result = '';
+    for (let index = 0; index < value.length; index++) {
+        if (value[index] !== '\\') {
+            result += value[index];
+            continue;
+        }
+        const escaped = value[++index];
+        if (escaped === undefined)
+            return undefined;
+        result += escaped;
+    }
+    return result;
 }
 /** Replace this local viewer pane with Neovim, then reattach it when Neovim exits. */
 export function openLinkedFileInPane(opts) {
-    let file;
-    try {
-        const url = new URL(opts.uri);
-        if (url.protocol !== 'file:')
-            return 'invalid';
-        file = fileURLToPath(url);
-    }
-    catch {
-        return 'invalid';
-    }
-    if (!existsSync(file))
+    if (!existsSync(opts.file))
         return 'missing';
     const attach = `crtr surface attach to ${shellQuote(opts.nodeId)}${opts.observer ? ' --observer' : ''}`;
-    const command = `nvim ${shellQuote(file)} || :; exec ${attach}`;
+    const command = `nvim ${shellQuote(opts.file)} || :; exec ${attach}`;
     opts.beforeRespawn();
     return respawnPaneInBackground({ pane: opts.pane, cwd: opts.cwd, env: viewerSplitEnv(), command }) ? 'opened' : 'failed';
 }

package/dist/clients/attach/session/keys.d.ts

@@ -31,7 +31,7 @@ export interface KeyHooks {
     toggleInboxStrip: () => void;
     cycleModelLadder: (direction: 'forward' | 'backward') => void;
     inspectLoadedCommand: () => void;
-    /** The file-review chord — open the transcript-file picker + review surface. */
+    /** The file-review chord — pick a transcript file and open its review window. */
     openFileReview: () => void;
     /** Search the current node's local profile project files. */
     openProfileFiles: () => void;

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

@@ -50,7 +50,7 @@ function profileSearchRoots(profileId) {
         return { projects: [], memory: null };
     try {
         const { profileId: resolvedId, manifest } = loadProfileManifest(profileId);
-        return { projects: manifest.projects, memory: profileMemoryDir(resolvedId) };
+        return { projects: manifest.projects.map((project) => project.path), memory: profileMemoryDir(resolvedId) };
     }
     catch {
         return { projects: [], memory: null };