@north-light/crouter 0.3.227 → 0.3.228

package/dist/core/exclusive-lock.js

@@ -5,6 +5,7 @@ const POLL_MS = 10;
 const DEFAULT_STALE_MS = 30_000;
 const DEFAULT_TIMEOUT_MS = 5_000;
 function pause(ms) { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
+function pauseAsync(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
 function markerPath(path, token) { return `${path}/${MARKER_PREFIX}${token}`; }
 function observedMarkerToken(path) {
     try {
@@ -122,3 +123,23 @@ export function withExclusiveDirectoryLock(path, operation, options = {}) {
             rmSync(lock.path, { recursive: true, force: true });
     }
 }
+/** Run an awaited operation under the same token-checked directory lock. */
+export async function withExclusiveDirectoryLockAsync(path, operation, options = {}) {
+    const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+    const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    let lock = tryAcquire(path, staleMs);
+    while (lock === null) {
+        if (Date.now() >= deadline) {
+            throw options.timeoutError?.() ?? new Error(`timed out waiting for the exclusive lock: ${path}`);
+        }
+        await pauseAsync(Math.min(POLL_MS, Math.max(0, deadline - Date.now())));
+        lock = tryAcquire(path, staleMs);
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        if (existsSync(markerPath(lock.path, lock.token)))
+            rmSync(lock.path, { recursive: true, force: true });
+    }
+}

package/dist/core/git.d.ts

@@ -13,7 +13,6 @@ export declare function clone(url: string, dest: string, opts?: {
     ref?: string;
     depth?: number;
 }): GitResult;
-export declare function pull(cwd: string): GitResult;
 export declare function fetch(cwd: string, ref?: string): GitResult;
 export declare function lsRemote(url: string): GitResult;
 export declare function currentSha(cwd: string): string | null;

package/dist/core/git.js

@@ -35,9 +35,6 @@ export function clone(url, dest, opts = {}) {
     }
     return res;
 }
-export function pull(cwd) {
-    return gitSync(['pull', '--ff-only'], cwd);
-}
 export function fetch(cwd, ref) {
     const args = ['fetch', 'origin'];
     if (ref)

package/dist/core/human/__tests__/integration/inbox-core.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/human/feedback-companion.js

@@ -16,6 +16,7 @@ import { headlessBrokerHost } from '../runtime/host.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { reviveNode } from '../runtime/revive.js';
 import { materializeSessionBranchAt } from '../runtime/session-branch.js';
+import { initializeForkContextExposure } from '../substrate/injected-store.js';
 import { pagePath } from './convention.js';
 export function feedbackCompanionBranchPath(dir) { return `${dir}/companion-branch.jsonl`; }
 /** Hex sha256 of the ticket's page document, recorded at first comment so the
@@ -73,6 +74,7 @@ export async function realizeFeedbackCompanion(args) {
         parent: args.senderNodeId,
         subscribe: false,
         forkFrom: branchFile,
+        forkSourceFile: branchFile,
         modelOverride: capture.modelSpec,
         reviewBinding: {
             kind: 'page_feedback',
@@ -85,6 +87,7 @@ export async function realizeFeedbackCompanion(args) {
         launch,
     });
     try {
+        initializeForkContextExposure(node.node_id, args.senderNodeId);
         reviveNode(node.node_id, { resume: false });
         if (!await awaitCompanionBind(node.node_id, COMPANION_BIND_DEADLINE_MS)) {
             throw new Error(`feedback companion did not bind within ${COMPANION_BIND_DEADLINE_MS}ms`);

package/dist/core/human/scan.js

@@ -1,4 +1,4 @@
-import { readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { claimPath, isResolved, pageManifestPath, reviewPath } from './convention.js';
 import { readJsonOrNull } from '../fs-utils.js';
@@ -27,6 +27,13 @@ function reviewSummary(dir, id) {
     return { dir, id, kind: 'review', title: review.title, subtitle: review.subtitle, file: review.file, output: review.output, source: review.source, blockedSince: review.blockedSince, claim: claimSummary(dir) };
 }
 function pageSummary(dir, id) {
+    // The tickets root IS the canvas node root, so all but a handful of these
+    // directories hold no page at all. Gate on the manifest's presence with one
+    // stat instead of letting `parsePage` throw: a thrown ENOENT carries a V8
+    // stack capture, which over thousands of node directories is the whole cost
+    // of a scan.
+    if (!existsSync(pageManifestPath(dir)))
+        return null;
     let manifest;
     try {
         manifest = parsePage(dir);

package/dist/core/keybindings/catalog.d.ts

@@ -4,12 +4,12 @@ type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools
 type TmuxMenuEntryAction = Exclude<TmuxMenuAction, 'open' | 'attach'> | `issue.${'idea' | 'bug'}`;
 type GraphAction = 'down' | 'up' | 'first' | 'last' | 'collapse-or-manager' | 'expand-or-child' | 'focus' | 'revive' | 'focus-manager' | 'close-subtree' | 'dismiss';
 type BrowseAction = 'quit' | 'down' | 'up' | 'first' | 'last' | 'expand-or-child' | 'collapse-or-parent' | 'toggle-fold' | 'tab-next' | 'tab-previous' | `tab.${1 | 2 | 3 | 4 | 5}` | 'close-subtree' | 'confirm-close' | 'sort' | 'scope' | 'profile' | 'residents' | 'preview' | 'search' | 'revive-now' | 'focus' | 'focus-background' | 'yank-id';
-type ProfileMenuAction = 'up' | 'down' | 'select' | 'accept-default' | 'abort' | `slot.${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}` | 'create' | 'search-existing' | 'use-root' | 'set-default' | 'add-directory' | 'unpin';
+type ProfileMenuAction = 'up' | 'down' | 'select' | 'accept-default' | 'abort' | `slot.${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}` | 'create' | 'search-existing' | 'use-root' | 'set-default' | 'add-directory' | 'unpin' | 'manage';
 type SetupAction = 'cancel' | 'tab-next' | 'tab-previous' | 'open' | 'list-down' | 'list-up' | 'toggle' | 'details' | 'advance' | 'cell-previous' | 'cell-next';
 type SetupKeybindingAction = 'edit' | 'commit-edit' | 'cancel-edit' | 'unbind' | 'reset-row' | 'reset-all' | 'save' | 'discard' | 'page-up' | 'page-down' | 'filter' | 'filter-delete' | 'filter-clear';
 type SetupModelsAction = 'open' | 'commit' | 'cancel' | 'scope-next';
 export type BindingId = `crtr.tmux.menu.${TmuxMenuAction}` | `crtr.tmux.menu.issue.${'idea' | 'bug'}` | AttachMenuBindingId | `crtr.tmux.menu-global.${TmuxMenuEntryAction}` | `crtr.tmux.node.${'next' | 'previous'}` | 'crtr.tmux.inbox.toggle' | `crtr.attach.scroll.${'up' | 'down' | 'page-up' | 'page-down' | 'live'}` | 'crtr.attach.mouse.toggle' | 'crtr.attach.copy.message' | 'crtr.attach.help.toggle' | `crtr.attach.search.${'next' | 'previous' | 'edit' | 'close'}` | AttachBindingId | `crtr.graph.${GraphAction}` | `crtr.graph.confirm.${'accept' | 'cancel'}` | `crtr.inspector.${'force-quit' | 'down' | 'up' | 'section-next' | 'section-prev' | 'page-down' | 'page-up' | 'toggle-detail' | 'cancel-item' | 'open-log' | 'confirm' | 'dismiss' | 'retarget' | 'refresh' | 'quit'}` | `crtr.browse.${BrowseAction}` | `crtr.browse.search.${'cancel' | 'commit' | 'delete' | 'quit'}` | `crtr.profile.menu.${ProfileMenuAction}` | `crtr.profile.search.${'up' | 'down' | 'pick' | 'back' | 'delete' | 'abort'}` | `crtr.setup.${SetupAction}` | `crtr.setup.confirm.${'accept' | 'back'}` | `crtr.setup.keybindings.${SetupKeybindingAction}` | `crtr.setup.models.${SetupModelsAction}`;
-export declare const BINDING_CATALOG: readonly [BindingDefinition<"crtr.tmux.menu.open">, BindingDefinition<"crtr.tmux.menu.attach">, ...(BindingDefinition<BindingId> | BindingDefinition<"crtr.tmux.node.next"> | BindingDefinition<"crtr.tmux.node.previous"> | BindingDefinition<"crtr.tmux.inbox.toggle"> | BindingDefinition<"crtr.attach.scroll.up"> | BindingDefinition<"crtr.attach.scroll.down"> | BindingDefinition<"crtr.attach.scroll.page-up"> | BindingDefinition<"crtr.attach.scroll.page-down"> | BindingDefinition<"crtr.attach.scroll.live"> | BindingDefinition<"crtr.attach.mouse.toggle"> | BindingDefinition<"crtr.attach.copy.message"> | BindingDefinition<"crtr.attach.search.next"> | BindingDefinition<"crtr.attach.search.previous"> | BindingDefinition<"crtr.attach.search.edit"> | BindingDefinition<"crtr.attach.search.close"> | BindingDefinition<"crtr.graph.down"> | BindingDefinition<"crtr.graph.up"> | BindingDefinition<"crtr.graph.first"> | BindingDefinition<"crtr.graph.last"> | BindingDefinition<"crtr.graph.collapse-or-manager"> | BindingDefinition<"crtr.graph.expand-or-child"> | BindingDefinition<"crtr.graph.focus"> | BindingDefinition<"crtr.graph.revive"> | BindingDefinition<"crtr.graph.focus-manager"> | BindingDefinition<"crtr.graph.close-subtree"> | BindingDefinition<"crtr.graph.dismiss"> | BindingDefinition<"crtr.graph.confirm.accept"> | BindingDefinition<"crtr.graph.confirm.cancel"> | BindingDefinition<"crtr.inspector.force-quit"> | BindingDefinition<"crtr.inspector.down"> | BindingDefinition<"crtr.inspector.up"> | BindingDefinition<"crtr.inspector.section-next"> | BindingDefinition<"crtr.inspector.section-prev"> | BindingDefinition<"crtr.inspector.page-down"> | BindingDefinition<"crtr.inspector.page-up"> | BindingDefinition<"crtr.inspector.toggle-detail"> | BindingDefinition<"crtr.inspector.cancel-item"> | BindingDefinition<"crtr.inspector.open-log"> | BindingDefinition<"crtr.inspector.confirm"> | BindingDefinition<"crtr.inspector.dismiss"> | BindingDefinition<"crtr.inspector.retarget"> | BindingDefinition<"crtr.inspector.refresh"> | BindingDefinition<"crtr.inspector.quit"> | BindingDefinition<"crtr.browse.quit"> | BindingDefinition<"crtr.browse.down"> | BindingDefinition<"crtr.browse.up"> | BindingDefinition<"crtr.browse.first"> | BindingDefinition<"crtr.browse.last"> | BindingDefinition<"crtr.browse.expand-or-child"> | BindingDefinition<"crtr.browse.collapse-or-parent"> | BindingDefinition<"crtr.browse.toggle-fold"> | BindingDefinition<"crtr.browse.tab-next"> | BindingDefinition<"crtr.browse.tab-previous"> | BindingDefinition<"crtr.browse.tab.2" | "crtr.browse.tab.1" | "crtr.browse.tab.3" | "crtr.browse.tab.4" | "crtr.browse.tab.5"> | BindingDefinition<"crtr.browse.close-subtree"> | BindingDefinition<"crtr.browse.confirm-close"> | BindingDefinition<"crtr.browse.sort"> | BindingDefinition<"crtr.browse.scope"> | BindingDefinition<"crtr.browse.profile"> | BindingDefinition<"crtr.browse.residents"> | BindingDefinition<"crtr.browse.preview"> | BindingDefinition<"crtr.browse.search"> | BindingDefinition<"crtr.browse.revive-now"> | BindingDefinition<"crtr.browse.focus"> | BindingDefinition<"crtr.browse.focus-background"> | BindingDefinition<"crtr.browse.yank-id"> | BindingDefinition<"crtr.browse.search.cancel"> | BindingDefinition<"crtr.browse.search.commit"> | BindingDefinition<"crtr.browse.search.delete"> | BindingDefinition<"crtr.browse.search.quit"> | BindingDefinition<"crtr.profile.menu.up"> | BindingDefinition<"crtr.profile.menu.down"> | BindingDefinition<"crtr.profile.menu.select"> | BindingDefinition<"crtr.profile.menu.accept-default"> | BindingDefinition<"crtr.profile.menu.abort"> | BindingDefinition<"crtr.profile.menu.slot.2" | "crtr.profile.menu.slot.1" | "crtr.profile.menu.slot.3" | "crtr.profile.menu.slot.4" | "crtr.profile.menu.slot.5" | "crtr.profile.menu.slot.6" | "crtr.profile.menu.slot.7" | "crtr.profile.menu.slot.8" | "crtr.profile.menu.slot.9">)[], BindingDefinition<"crtr.profile.menu.create">, BindingDefinition<"crtr.profile.menu.search-existing">, BindingDefinition<"crtr.profile.menu.use-root">, BindingDefinition<"crtr.profile.menu.set-default">, BindingDefinition<"crtr.profile.menu.add-directory">, BindingDefinition<"crtr.profile.menu.unpin">, BindingDefinition<"crtr.profile.search.up">, BindingDefinition<"crtr.profile.search.down">, BindingDefinition<"crtr.profile.search.pick">, BindingDefinition<"crtr.profile.search.back">, BindingDefinition<"crtr.profile.search.delete">, BindingDefinition<"crtr.profile.search.abort">, BindingDefinition<"crtr.setup.cancel">, BindingDefinition<"crtr.setup.tab-next">, BindingDefinition<"crtr.setup.tab-previous">, BindingDefinition<"crtr.setup.open">, BindingDefinition<"crtr.setup.list-down">, BindingDefinition<"crtr.setup.list-up">, BindingDefinition<"crtr.setup.toggle">, BindingDefinition<"crtr.setup.details">, BindingDefinition<"crtr.setup.advance">, BindingDefinition<"crtr.setup.confirm.accept">, BindingDefinition<"crtr.setup.confirm.back">, BindingDefinition<"crtr.setup.keybindings.edit">, BindingDefinition<"crtr.setup.keybindings.commit-edit">, BindingDefinition<"crtr.setup.keybindings.cancel-edit">, BindingDefinition<"crtr.setup.keybindings.unbind">, BindingDefinition<"crtr.setup.keybindings.reset-row">, BindingDefinition<"crtr.setup.keybindings.reset-all">, BindingDefinition<"crtr.setup.keybindings.save">, BindingDefinition<"crtr.setup.keybindings.discard">, BindingDefinition<"crtr.setup.keybindings.page-up">, BindingDefinition<"crtr.setup.keybindings.page-down">, BindingDefinition<"crtr.setup.keybindings.filter">, BindingDefinition<"crtr.setup.keybindings.filter-delete">, BindingDefinition<"crtr.setup.keybindings.filter-clear">, BindingDefinition<"crtr.setup.cell-previous">, BindingDefinition<"crtr.setup.cell-next">, BindingDefinition<"crtr.setup.models.open">, BindingDefinition<"crtr.setup.models.scope-next">, BindingDefinition<"crtr.setup.models.commit">, BindingDefinition<"crtr.setup.models.cancel">];
+export declare const BINDING_CATALOG: readonly [BindingDefinition<"crtr.tmux.menu.open">, BindingDefinition<"crtr.tmux.menu.attach">, ...(BindingDefinition<BindingId> | BindingDefinition<"crtr.tmux.node.next"> | BindingDefinition<"crtr.tmux.node.previous"> | BindingDefinition<"crtr.tmux.inbox.toggle"> | BindingDefinition<"crtr.attach.scroll.up"> | BindingDefinition<"crtr.attach.scroll.down"> | BindingDefinition<"crtr.attach.scroll.page-up"> | BindingDefinition<"crtr.attach.scroll.page-down"> | BindingDefinition<"crtr.attach.scroll.live"> | BindingDefinition<"crtr.attach.mouse.toggle"> | BindingDefinition<"crtr.attach.copy.message"> | BindingDefinition<"crtr.attach.search.next"> | BindingDefinition<"crtr.attach.search.previous"> | BindingDefinition<"crtr.attach.search.edit"> | BindingDefinition<"crtr.attach.search.close"> | BindingDefinition<"crtr.graph.down"> | BindingDefinition<"crtr.graph.up"> | BindingDefinition<"crtr.graph.first"> | BindingDefinition<"crtr.graph.last"> | BindingDefinition<"crtr.graph.collapse-or-manager"> | BindingDefinition<"crtr.graph.expand-or-child"> | BindingDefinition<"crtr.graph.focus"> | BindingDefinition<"crtr.graph.revive"> | BindingDefinition<"crtr.graph.focus-manager"> | BindingDefinition<"crtr.graph.close-subtree"> | BindingDefinition<"crtr.graph.dismiss"> | BindingDefinition<"crtr.graph.confirm.accept"> | BindingDefinition<"crtr.graph.confirm.cancel"> | BindingDefinition<"crtr.inspector.force-quit"> | BindingDefinition<"crtr.inspector.down"> | BindingDefinition<"crtr.inspector.up"> | BindingDefinition<"crtr.inspector.section-next"> | BindingDefinition<"crtr.inspector.section-prev"> | BindingDefinition<"crtr.inspector.page-down"> | BindingDefinition<"crtr.inspector.page-up"> | BindingDefinition<"crtr.inspector.toggle-detail"> | BindingDefinition<"crtr.inspector.cancel-item"> | BindingDefinition<"crtr.inspector.open-log"> | BindingDefinition<"crtr.inspector.confirm"> | BindingDefinition<"crtr.inspector.dismiss"> | BindingDefinition<"crtr.inspector.retarget"> | BindingDefinition<"crtr.inspector.refresh"> | BindingDefinition<"crtr.inspector.quit"> | BindingDefinition<"crtr.browse.quit"> | BindingDefinition<"crtr.browse.down"> | BindingDefinition<"crtr.browse.up"> | BindingDefinition<"crtr.browse.first"> | BindingDefinition<"crtr.browse.last"> | BindingDefinition<"crtr.browse.expand-or-child"> | BindingDefinition<"crtr.browse.collapse-or-parent"> | BindingDefinition<"crtr.browse.toggle-fold"> | BindingDefinition<"crtr.browse.tab-next"> | BindingDefinition<"crtr.browse.tab-previous"> | BindingDefinition<"crtr.browse.tab.2" | "crtr.browse.tab.1" | "crtr.browse.tab.3" | "crtr.browse.tab.4" | "crtr.browse.tab.5"> | BindingDefinition<"crtr.browse.close-subtree"> | BindingDefinition<"crtr.browse.confirm-close"> | BindingDefinition<"crtr.browse.sort"> | BindingDefinition<"crtr.browse.scope"> | BindingDefinition<"crtr.browse.profile"> | BindingDefinition<"crtr.browse.residents"> | BindingDefinition<"crtr.browse.preview"> | BindingDefinition<"crtr.browse.search"> | BindingDefinition<"crtr.browse.revive-now"> | BindingDefinition<"crtr.browse.focus"> | BindingDefinition<"crtr.browse.focus-background"> | BindingDefinition<"crtr.browse.yank-id"> | BindingDefinition<"crtr.browse.search.cancel"> | BindingDefinition<"crtr.browse.search.commit"> | BindingDefinition<"crtr.browse.search.delete"> | BindingDefinition<"crtr.browse.search.quit"> | BindingDefinition<"crtr.profile.menu.up"> | BindingDefinition<"crtr.profile.menu.down"> | BindingDefinition<"crtr.profile.menu.select"> | BindingDefinition<"crtr.profile.menu.accept-default"> | BindingDefinition<"crtr.profile.menu.abort"> | BindingDefinition<"crtr.profile.menu.slot.2" | "crtr.profile.menu.slot.1" | "crtr.profile.menu.slot.3" | "crtr.profile.menu.slot.4" | "crtr.profile.menu.slot.5" | "crtr.profile.menu.slot.6" | "crtr.profile.menu.slot.7" | "crtr.profile.menu.slot.8" | "crtr.profile.menu.slot.9">)[], BindingDefinition<"crtr.profile.menu.create">, BindingDefinition<"crtr.profile.menu.search-existing">, BindingDefinition<"crtr.profile.menu.use-root">, BindingDefinition<"crtr.profile.menu.set-default">, BindingDefinition<"crtr.profile.menu.add-directory">, BindingDefinition<"crtr.profile.menu.unpin">, BindingDefinition<"crtr.profile.menu.manage">, BindingDefinition<"crtr.profile.search.up">, BindingDefinition<"crtr.profile.search.down">, BindingDefinition<"crtr.profile.search.pick">, BindingDefinition<"crtr.profile.search.back">, BindingDefinition<"crtr.profile.search.delete">, BindingDefinition<"crtr.profile.search.abort">, BindingDefinition<"crtr.setup.cancel">, BindingDefinition<"crtr.setup.tab-next">, BindingDefinition<"crtr.setup.tab-previous">, BindingDefinition<"crtr.setup.open">, BindingDefinition<"crtr.setup.list-down">, BindingDefinition<"crtr.setup.list-up">, BindingDefinition<"crtr.setup.toggle">, BindingDefinition<"crtr.setup.details">, BindingDefinition<"crtr.setup.advance">, BindingDefinition<"crtr.setup.confirm.accept">, BindingDefinition<"crtr.setup.confirm.back">, BindingDefinition<"crtr.setup.keybindings.edit">, BindingDefinition<"crtr.setup.keybindings.commit-edit">, BindingDefinition<"crtr.setup.keybindings.cancel-edit">, BindingDefinition<"crtr.setup.keybindings.unbind">, BindingDefinition<"crtr.setup.keybindings.reset-row">, BindingDefinition<"crtr.setup.keybindings.reset-all">, BindingDefinition<"crtr.setup.keybindings.save">, BindingDefinition<"crtr.setup.keybindings.discard">, BindingDefinition<"crtr.setup.keybindings.page-up">, BindingDefinition<"crtr.setup.keybindings.page-down">, BindingDefinition<"crtr.setup.keybindings.filter">, BindingDefinition<"crtr.setup.keybindings.filter-delete">, BindingDefinition<"crtr.setup.keybindings.filter-clear">, BindingDefinition<"crtr.setup.cell-previous">, BindingDefinition<"crtr.setup.cell-next">, BindingDefinition<"crtr.setup.models.open">, BindingDefinition<"crtr.setup.models.scope-next">, BindingDefinition<"crtr.setup.models.commit">, BindingDefinition<"crtr.setup.models.cancel">];
 export declare const BINDING_IDS: ReadonlySet<string>;
 /** True for an action whose direct gesture is handled inside an attach viewer.
  *  Tmux menu selectors and root shortcuts are chrome, not pane input. */

package/dist/core/keybindings/catalog.js

@@ -77,7 +77,7 @@ export const BINDING_CATALOG = Object.freeze([
     ...attachEntry('crtr.tmux.menu.attach.model-ladder.previous', 'crtr.attach.model-ladder.previous', 'Previous model', 'Move to the previous model ladder rung.', ['['], ['alt+shift+m']),
     ...attachEntry('crtr.tmux.menu.attach.command.inspect', 'crtr.attach.command.inspect', 'Inspect loaded command', 'Open the loaded slash command’s expanded prompt.', ['h'], ['alt+shift+h']),
     ...attachEntry('crtr.tmux.menu.attach.file-review', 'crtr.attach.file-review', 'Review a file', 'Open a line-anchored review of a file named in the transcript.', [], ['alt+shift+r']),
-    ...attachEntry('crtr.tmux.menu.attach.profile-files', 'crtr.attach.profile-files', 'Search profile files', 'Search files across the node’s profile projects, profile memory, cwd, and ancestor crouter memory stores.', ['f'], ['ctrl+f']),
+    ...attachEntry('crtr.tmux.menu.attach.profile-files', 'crtr.attach.profile-files', 'Search profile files', 'Fuzzy-match path segments across the node family’s working directories, profile projects and memory, and ancestor crouter memory stores; Ctrl+Y copies a selected path.', ['f'], ['ctrl+f']),
     ...attachEntry('crtr.tmux.menu.attach.search', 'crtr.attach.search', 'Search transcript', 'Search the transcript as it is currently displayed — folded tool output is not searched until it is unfolded.', ['/'], ['alt+/']),
     ...attachEntry('crtr.tmux.menu.attach.whip', 'crtr.attach.whip', 'Whip agent', 'Interrupt the agent and send a playful command.', ['w'], []),
     b('crtr.attach.scroll.up', 'Attach', 'Scroll up', 'Scroll the transcript one line up.', ['shift+up'], 'terminal', ATTACH_CONTEXTS),
@@ -171,6 +171,7 @@ function profileBindings() {
         b('crtr.profile.menu.set-default', 'Profiles', 'Set default', 'Set the selected profile as default.', ['d'], 'terminal', [menu]),
         b('crtr.profile.menu.add-directory', 'Profiles', 'Add directory', 'Add a directory to the profile.', ['a'], 'terminal', [menu]),
         b('crtr.profile.menu.unpin', 'Profiles', 'Unpin directory', 'Unpin the selected directory.', ['u'], 'terminal', [menu]),
+        b('crtr.profile.menu.manage', 'Profiles', 'Manage profiles', 'Open the profiles settings page in a popup.', ['v'], 'terminal', [menu]),
         b('crtr.profile.search.up', 'Profiles', 'Move up', 'Move to the previous search result.', ['up', 'ctrl+p'], 'terminal', [search]),
         b('crtr.profile.search.down', 'Profiles', 'Move down', 'Move to the next search result.', ['down', 'ctrl+n'], 'terminal', [search]),
         b('crtr.profile.search.pick', 'Profiles', 'Pick profile', 'Pick the highlighted profile.', ['enter'], 'terminal', [search]),

package/dist/core/memory/doc-link-grammar.js

@@ -16,10 +16,10 @@
 // This module never resolves anything: `findDocLinks` returns candidate links;
 // a caller decides a link is live by testing `name` against the corpus of
 // resolvable canonical names.
-// A canonical doc name: one or more `[A-Za-z0-9_-]+` segments joined by `/`.
+// A canonical doc name: one or more `[A-Za-z0-9._-]+` segments joined by `/`.
 // Anything else between `[[` `]]` (spaces, `|` aliases, empty segments) is NOT
 // a doc link — the grammar has no alias/label form, by design.
-const NAME_RE = /^[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/;
+const NAME_RE = /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
 const LINK_RE = /\[\[([^\[\]\n]+)\]\]/g;
 /** Is `name` a well-formed canonical doc-link name? */
 export function isDocLinkName(name) {

package/dist/core/memory/history.d.ts

@@ -1,3 +1,4 @@
+import type { MemoryDoc } from '../memory-resolver.js';
 /** Sidecar tree name under a store's `memory/` dir. Dot-prefixed and holding
  *  only `.jsonl`, so every substrate scan (which filters to `*.md`, and in
  *  `lint`'s case skips dot-dirs outright) passes it over without an exclusion
@@ -37,6 +38,29 @@ export declare function buildHistoryRecord(input: {
     before: string;
     after: string;
 }): HistoryRecord;
+/** Derive a live document's sidecar from its descriptor. The descriptor's
+ * physical path is authoritative: canonical names carry a project namespace,
+ * while sidecars remain in the owning store's physical tree. */
+export declare function historyLogPathForDoc(doc: Pick<MemoryDoc, 'root' | 'path'>): string;
+export interface DeletedHistoryCandidate {
+    path: string;
+    representation: 'directory-index' | 'leaf-file';
+    winner: boolean;
+}
+export interface DeletedHistoryResolution {
+    logPath: string;
+    candidates: readonly DeletedHistoryCandidate[];
+    collision?: {
+        paths: readonly string[];
+        winner: string;
+    };
+}
+/** Resolve a deleted document's physical history without reintroducing a
+ * canonical-name fallback. `localName` is already stripped of the selected
+ * project's exact namespace. The directory-index sidecar is deliberately
+ * probed first, and therefore wins deterministically if both physical forms
+ * survive; callers can expose `candidates`/`collision` for diagnostics. */
+export declare function resolveDeletedHistoryLogPath(storeRoot: string, localName: string): DeletedHistoryResolution | null;
 /** Append one record. Single write of one line — concurrent appends interleave
  *  whole records, and every record stands alone, so no lock is needed. */
 export declare function appendHistoryRecord(logPath: string, record: HistoryRecord): void;

package/dist/core/memory/history.js

@@ -10,11 +10,12 @@
 // The raw file is the consumer contract: an external reader (a product surface
 // reading a store off disk) parses one JSON object per line and computes its
 // own diffs. Nothing here shells out to git.
-import { appendFileSync } from 'node:fs';
+import { appendFileSync, readdirSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { ensureDir, pathExists, readText } from '../fs-utils.js';
 import { general } from '../errors.js';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
+import { normalizeNameSegment } from './identity.js';
 /** Sidecar tree name under a store's `memory/` dir. Dot-prefixed and holding
  *  only `.jsonl`, so every substrate scan (which filters to `*.md`, and in
  *  `lint`'s case skips dot-dirs outright) passes it over without an exclusion
@@ -48,6 +49,70 @@ export function buildHistoryRecord(input) {
     };
     return record;
 }
+/** Derive a live document's sidecar from its descriptor. The descriptor's
+ * physical path is authoritative: canonical names carry a project namespace,
+ * while sidecars remain in the owning store's physical tree. */
+export function historyLogPathForDoc(doc) {
+    return historyLogPathFor(doc.root, doc.path);
+}
+function matchingDirs(parent, segment) {
+    let entries;
+    try {
+        entries = readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isDirectory() && normalizeNameSegment(entry.name) === segment)
+        .sort((a, b) => (a.name === segment ? -1 : b.name === segment ? 1 : a.name.localeCompare(b.name)))
+        .map((entry) => join(parent, entry.name));
+}
+function matchingFiles(parent, stem) {
+    let entries;
+    try {
+        entries = readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl') && normalizeNameSegment(entry.name.slice(0, -'.jsonl'.length)) === stem)
+        .sort((a, b) => (a.name === `${stem}.jsonl` ? -1 : b.name === `${stem}.jsonl` ? 1 : a.name.localeCompare(b.name)))
+        .map((entry) => join(parent, entry.name));
+}
+function historyFilesForSegments(historyDir, segments, stem) {
+    let parents = [historyDir];
+    for (const segment of segments) {
+        parents = parents.flatMap((parent) => matchingDirs(parent, segment));
+        if (parents.length === 0)
+            return [];
+    }
+    return parents.flatMap((parent) => matchingFiles(parent, stem));
+}
+/** Resolve a deleted document's physical history without reintroducing a
+ * canonical-name fallback. `localName` is already stripped of the selected
+ * project's exact namespace. The directory-index sidecar is deliberately
+ * probed first, and therefore wins deterministically if both physical forms
+ * survive; callers can expose `candidates`/`collision` for diagnostics. */
+export function resolveDeletedHistoryLogPath(storeRoot, localName) {
+    const segments = localName.split('/').filter((segment) => segment !== '').map(normalizeNameSegment);
+    const historyDir = join(storeRoot, HISTORY_DIR);
+    const indexPaths = historyFilesForSegments(historyDir, segments, 'INDEX');
+    const leafPaths = segments.length === 0 ? [] : historyFilesForSegments(historyDir, segments.slice(0, -1), segments[segments.length - 1]);
+    const candidates = [
+        ...indexPaths.map((path) => ({ path, representation: 'directory-index', winner: false })),
+        ...leafPaths.map((path) => ({ path, representation: 'leaf-file', winner: false })),
+    ];
+    if (candidates.length === 0)
+        return null;
+    candidates[0].winner = true;
+    return {
+        logPath: candidates[0].path,
+        candidates,
+        ...(candidates.length > 1 ? { collision: { paths: candidates.map((candidate) => candidate.path), winner: candidates[0].path } } : {}),
+    };
+}
 /** Append one record. Single write of one line — concurrent appends interleave
  *  whole records, and every record stands alone, so no lock is needed. */
 export function appendHistoryRecord(logPath, record) {

package/dist/core/memory/identity.d.ts

@@ -0,0 +1,65 @@
+/** The filename (and path segment) whose document fronts its directory. */
+export declare const INDEX_SEGMENT = "INDEX";
+/** Strip an optional `NN-` ordering prefix from ONE segment. */
+export declare function normalizeNameSegment(segment: string): string;
+/** Slugify one authored or filesystem label into a canonical segment. */
+export declare function slugCanonicalSegment(raw: string): string;
+/** Slugify a derived label into canonical path segments. Empty segments are
+ * intentionally dropped; owner paths use slugCanonicalSegment directly. */
+export declare function slugCanonicalPath(raw: string): string;
+/** Strip the ordering prefix from EVERY segment of a slash-separated name:
+ *  `01-spine/00-has-manager` -> `spine/has-manager`. */
+export declare function normalizeDocName(name: string): string;
+/** Split a name into segments, dropping empties from `//`, a leading `/`, or an
+ *  empty name. */
+export declare function canonicalSegments(name: string): string[];
+/** The canonical directory containing `name`, or `''` at the top. */
+export declare function canonicalParent(name: string): string;
+/** Remove EXACTLY ONE trailing `INDEX` segment. `a/INDEX` -> `a`; `INDEX` ->
+ *  `''` (a store root); `a/INDEX/INDEX` -> `a/INDEX` (the inner segment is an
+ *  ordinary directory name). */
+export declare function collapseTrailingIndex(name: string): string;
+export type DocRepresentation = 'leaf-file' | 'directory-index';
+/** Which form a store-relative markdown path takes. */
+export declare function representationForPath(physicalRelativePath: string): DocRepresentation;
+/** Store-local name derived from a store-relative markdown path: ordering
+ *  prefixes stripped from every segment and one trailing `INDEX` collapsed.
+ *  Empty only for a store root `INDEX.md`. */
+export declare function localNameFromPath(physicalRelativePath: string): string;
+/** The store-relative markdown path a local name occupies in a given form.
+ *  Both forms are checked before any create or move, so occupancy never depends
+ *  on which one a store happens to use. */
+export declare function physicalRelativePathFor(localName: string, representation: DocRepresentation): string;
+/** A document's explicit frontmatter `name` as a local name — normalized with
+ *  one trailing `INDEX` collapsed — or `null` when it carries none. */
+export declare function explicitLocalName(fm: Record<string, unknown> | null | undefined): string | null;
+/** A document's store-local name: its explicit frontmatter `name` when present,
+ *  else the path-derived local name. Explicit names are local to their store —
+ *  they never carry the store's namespace. */
+export declare function resolveLocalName(fm: Record<string, unknown> | null | undefined, pathDerivedLocalName: string): string;
+/** namespace ⊕ local — the only address. Composition is unconditional: a local
+ *  name that already looks namespace-prefixed is composed anyway, so identity
+ *  never depends on string coincidence. An empty result means a namespace-less
+ *  store root, which has no valid canonical identity. */
+export declare function composeCanonicalName(namespace: string, localName: string): string;
+/** The canonical directory a document's `./` memory-read entries match against:
+ *  a directory document anchors at its own name, an ordinary leaf at its
+ *  canonical parent. */
+export declare function routingAnchorFor(canonicalName: string, representation: DocRepresentation): string;
+/** The local name a canonical name has inside `namespace`, or `null` when it
+ *  falls outside it. Exact on segment boundaries: `a/bc` is not inside `a/b`.
+ *  The namespace itself yields `''` — the store root document. */
+export declare function stripNamespace(canonicalName: string, namespace: string): string | null;
+export type IdentityValidation = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/** A project store's declared namespace, or an installed plugin's mount prefix:
+ *  one or more normalized segments, never ending in `INDEX`. */
+export declare function validateNamespace(namespace: string): IdentityValidation;
+/** An explicit non-root `name:`: a non-empty local name, never ending in
+ *  `INDEX` (its directory name is the identity) and never carrying its own
+ *  store's namespace. */
+export declare function validateExplicitLocalName(localName: string, namespace?: string): IdentityValidation;

package/dist/core/memory/identity.js

@@ -0,0 +1,185 @@
+// identity.ts — the ONE memory-identity rule. Every loader, placement helper,
+// linter, and migration derives names here rather than reproducing string
+// arithmetic: a document has a store-local name, its store declares a namespace
+// (a project's declaration, an installed plugin's mount prefix, or empty), and
+// its canonical name — the only address resolution accepts — is namespace ⊕
+// local. Pure and side-effect free.
+// ---------------------------------------------------------------------------
+// Segment normalization — the optional `NN-` ordering pin. A physical path may
+// carry a two-digit prefix on any segment (`00-runtime-base/`, `01-spine/`)
+// purely to pin structural order against natural sort. The prefix is NEVER part
+// of identity: only the physical path keeps it.
+// ---------------------------------------------------------------------------
+const NUMERIC_PREFIX_RE = /^\d{2}-/;
+const SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
+/** The filename (and path segment) whose document fronts its directory. */
+export const INDEX_SEGMENT = 'INDEX';
+/** Strip an optional `NN-` ordering prefix from ONE segment. */
+export function normalizeNameSegment(segment) {
+    return segment.replace(NUMERIC_PREFIX_RE, '');
+}
+/** Slugify one authored or filesystem label into a canonical segment. */
+export function slugCanonicalSegment(raw) {
+    return normalizeNameSegment(raw.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, ''));
+}
+/** Slugify a derived label into canonical path segments. Empty segments are
+ * intentionally dropped; owner paths use slugCanonicalSegment directly. */
+export function slugCanonicalPath(raw) {
+    return raw
+        .replace(/\\/g, '/')
+        .replace(/\.md$/i, '')
+        .split('/')
+        .map(slugCanonicalSegment)
+        .filter(Boolean)
+        .join('/');
+}
+/** Strip the ordering prefix from EVERY segment of a slash-separated name:
+ *  `01-spine/00-has-manager` -> `spine/has-manager`. */
+export function normalizeDocName(name) {
+    return name.split('/').map(normalizeNameSegment).join('/');
+}
+/** Split a name into segments, dropping empties from `//`, a leading `/`, or an
+ *  empty name. */
+export function canonicalSegments(name) {
+    return name.split('/').filter((s) => s !== '');
+}
+/** The canonical directory containing `name`, or `''` at the top. */
+export function canonicalParent(name) {
+    const segments = canonicalSegments(name);
+    return segments.slice(0, -1).join('/');
+}
+/** Remove EXACTLY ONE trailing `INDEX` segment. `a/INDEX` -> `a`; `INDEX` ->
+ *  `''` (a store root); `a/INDEX/INDEX` -> `a/INDEX` (the inner segment is an
+ *  ordinary directory name). */
+export function collapseTrailingIndex(name) {
+    const segments = canonicalSegments(name);
+    if (segments[segments.length - 1] === INDEX_SEGMENT)
+        segments.pop();
+    return segments.join('/');
+}
+/** Normalized identity segments of a store-relative markdown path, extension
+ *  stripped. */
+function pathIdentitySegments(physicalRelativePath) {
+    return canonicalSegments(physicalRelativePath.replace(/\\/g, '/').replace(/\.md$/i, '')).map(normalizeNameSegment);
+}
+/** Which form a store-relative markdown path takes. */
+export function representationForPath(physicalRelativePath) {
+    const segments = pathIdentitySegments(physicalRelativePath);
+    return segments[segments.length - 1] === INDEX_SEGMENT ? 'directory-index' : 'leaf-file';
+}
+/** Store-local name derived from a store-relative markdown path: ordering
+ *  prefixes stripped from every segment and one trailing `INDEX` collapsed.
+ *  Empty only for a store root `INDEX.md`. */
+export function localNameFromPath(physicalRelativePath) {
+    return collapseTrailingIndex(pathIdentitySegments(physicalRelativePath).join('/'));
+}
+/** The store-relative markdown path a local name occupies in a given form.
+ *  Both forms are checked before any create or move, so occupancy never depends
+ *  on which one a store happens to use. */
+export function physicalRelativePathFor(localName, representation) {
+    const local = canonicalSegments(localName).join('/');
+    if (local === '') {
+        if (representation === 'leaf-file')
+            throw new Error('a store root document has no leaf-file representation');
+        return `${INDEX_SEGMENT}.md`;
+    }
+    return representation === 'directory-index' ? `${local}/${INDEX_SEGMENT}.md` : `${local}.md`;
+}
+// ---------------------------------------------------------------------------
+// Local name and canonical composition.
+// ---------------------------------------------------------------------------
+/** A document's explicit frontmatter `name` as a local name — normalized with
+ *  one trailing `INDEX` collapsed — or `null` when it carries none. */
+export function explicitLocalName(fm) {
+    const raw = fm?.['name'];
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return null;
+    return collapseTrailingIndex(normalizeDocName(raw.trim()));
+}
+/** A document's store-local name: its explicit frontmatter `name` when present,
+ *  else the path-derived local name. Explicit names are local to their store —
+ *  they never carry the store's namespace. */
+export function resolveLocalName(fm, pathDerivedLocalName) {
+    return explicitLocalName(fm) ?? pathDerivedLocalName;
+}
+/** namespace ⊕ local — the only address. Composition is unconditional: a local
+ *  name that already looks namespace-prefixed is composed anyway, so identity
+ *  never depends on string coincidence. An empty result means a namespace-less
+ *  store root, which has no valid canonical identity. */
+export function composeCanonicalName(namespace, localName) {
+    const ns = canonicalSegments(namespace).join('/');
+    const local = canonicalSegments(localName).join('/');
+    if (ns === '')
+        return local;
+    return local === '' ? ns : `${ns}/${local}`;
+}
+/** The canonical directory a document's `./` memory-read entries match against:
+ *  a directory document anchors at its own name, an ordinary leaf at its
+ *  canonical parent. */
+export function routingAnchorFor(canonicalName, representation) {
+    return representation === 'directory-index' ? canonicalSegments(canonicalName).join('/') : canonicalParent(canonicalName);
+}
+/** The local name a canonical name has inside `namespace`, or `null` when it
+ *  falls outside it. Exact on segment boundaries: `a/bc` is not inside `a/b`.
+ *  The namespace itself yields `''` — the store root document. */
+export function stripNamespace(canonicalName, namespace) {
+    const name = canonicalSegments(canonicalName);
+    const ns = canonicalSegments(namespace);
+    for (let i = 0; i < ns.length; i++) {
+        if (name[i] !== ns[i])
+            return null;
+    }
+    return name.slice(ns.length).join('/');
+}
+function invalidSegmentReason(name) {
+    for (const segment of name.split('/')) {
+        if (segment === '')
+            return `empty segment in \`${name}\``;
+        if (segment === '.' || segment === '..')
+            return `relative segment \`${segment}\` in \`${name}\``;
+        if (!SEGMENT_RE.test(segment))
+            return `segment \`${segment}\` is not [A-Za-z0-9._-]`;
+        if (NUMERIC_PREFIX_RE.test(segment)) {
+            return `segment \`${segment}\` carries an \`NN-\` ordering prefix, which is physical-path-only — use \`${normalizeNameSegment(segment)}\``;
+        }
+    }
+    return null;
+}
+/** A project store's declared namespace, or an installed plugin's mount prefix:
+ *  one or more normalized segments, never ending in `INDEX`. */
+export function validateNamespace(namespace) {
+    if (namespace.trim() !== namespace)
+        return { ok: false, reason: 'namespace has surrounding whitespace' };
+    if (namespace === '')
+        return { ok: false, reason: 'namespace is empty' };
+    const badSegment = invalidSegmentReason(namespace);
+    if (badSegment !== null)
+        return { ok: false, reason: badSegment };
+    if (canonicalSegments(namespace).pop() === INDEX_SEGMENT) {
+        return { ok: false, reason: `namespace ends in \`${INDEX_SEGMENT}\`` };
+    }
+    return { ok: true };
+}
+/** An explicit non-root `name:`: a non-empty local name, never ending in
+ *  `INDEX` (its directory name is the identity) and never carrying its own
+ *  store's namespace. */
+export function validateExplicitLocalName(localName, namespace = '') {
+    if (localName.trim() !== localName)
+        return { ok: false, reason: 'name has surrounding whitespace' };
+    if (localName === '')
+        return { ok: false, reason: 'name is empty' };
+    const badSegment = invalidSegmentReason(localName);
+    if (badSegment !== null)
+        return { ok: false, reason: badSegment };
+    if (canonicalSegments(localName).pop() === INDEX_SEGMENT) {
+        const collapsed = collapseTrailingIndex(localName);
+        return {
+            ok: false,
+            reason: `name ends in \`${INDEX_SEGMENT}\` — a directory document answers at its directory name${collapsed === '' ? '' : `, so use \`${collapsed}\``}`,
+        };
+    }
+    if (namespace !== '' && stripNamespace(localName, namespace) !== null) {
+        return { ok: false, reason: `name repeats its store's namespace \`${namespace}\` — explicit names are store-local` };
+    }
+    return { ok: true };
+}

package/dist/core/memory/inline-ref-guidance.d.ts

@@ -1,5 +1,5 @@
 /**
- * Resolve every slash token in `text` against `names` (a
+ * Resolve every slash token in `text` against `names` (the exact canonical
  * `buildRefInventory().names` set), collapse duplicates, and return one
  * directive line per distinct resolved ref in FIRST-APPEARANCE order.
  * Returns `null` when no token resolves, so the broker sends no guidance

package/dist/core/memory/inline-ref-guidance.js

@@ -11,7 +11,7 @@
 import { findRefTokens } from './inline-ref-grammar.js';
 const GUIDANCE_HEADER = 'The user explicitly called out specific memories. Read the relevant mentioned memory files:';
 /**
- * Resolve every slash token in `text` against `names` (a
+ * Resolve every slash token in `text` against `names` (the exact canonical
  * `buildRefInventory().names` set), collapse duplicates, and return one
  * directive line per distinct resolved ref in FIRST-APPEARANCE order.
  * Returns `null` when no token resolves, so the broker sends no guidance

package/dist/core/memory/inline-ref-inventory.d.ts

@@ -1,14 +1,7 @@
 import type { RefMeta } from '../runtime/broker-protocol.js';
-/**
- * Build the inline memory-reference inventory: every referenceable document
- * in this node's corpus, precedence-deduped first-wins by canonical name,
- * both kinds, no gate/rung/`slash` filtering. Returns display metadata
- * (`refs`, stably sorted by winning scope then name) plus the resolution set
- * (`names` — doc names plus every proper directory prefix, because a bare-dir
- * ref is a legal listing link) that both the broker's per-submission resolver
- * and `buildGuidance` test tokens against. `refs` additionally labels Gateway
- * eligibility; the terminal viewer still receives every referenceable row.
- */
+/** Build the inline inventory from exact target-view winners. `refs` carries
+ * metadata rows; `names` adds only canonical directory nodes with members for
+ * browse links. Gates, rungs, and `slash` do not affect referenceability. */
 export declare function buildRefInventory(): {
     refs: RefMeta[];
     names: Set<string>;