@north-light/crouter 0.3.232 → 0.3.234

package/dist/commands/memory/find.js

@@ -126,7 +126,7 @@ export const findLeaf = defineLeaf({
         const units = selector.store !== null
             ? searchUnits(kindFilter, loadMemoryStoreView(requireMountedStore(selector.store), false).docs, false)
             : searchUnits(kindFilter, listAllMemoryDocs(selector.scope, false, true), true);
-        // --- grep mode: regex over every unit's body, one row per matching line ---
+        // grep mode: regex over every unit's body, one row per matching line
         if (grep) {
             let regex;
             try {
@@ -167,7 +167,7 @@ export const findLeaf = defineLeaf({
             registerMemoryListingExposure(listingIdentity);
             return output;
         }
-        // --- ranked mode: weighted relevance over name/routing-line/short-form(+body) ---
+        // ranked mode: weighted relevance over name/routing-line/short-form(+body)
         const terms = query
             .toLowerCase()
             .split(/\s+/)

package/dist/commands/memory/lint.js

@@ -3,6 +3,7 @@
 // verification, the plugin candidate gate, and the build's builtin gate consume
 // too; this leaf only picks WHAT to lint (a target view, or one exact store
 // with --dir) and shapes the findings for the CLI.
+import { envProfileId } from '../../shared/env.js';
 import { defineLeaf } from '../../core/command.js';
 import { warn } from '../../core/output.js';
 import { ExitCode } from '../../types.js';
@@ -26,7 +27,7 @@ function findingRow(finding) {
 function resolvableNamesForStore(store) {
     const view = loadMemoryTargetView({
         cwd: store.ownerDir ?? store.storeRoot,
-        profileId: process.env['CRTR_PROFILE_ID'] || null,
+        profileId: envProfileId() || null,
         nodeId: null,
     }, { quiet: true, includeDescendants: true });
     return resolvableCanonicalNames(view.docs);

package/dist/commands/memory/read.d.ts

@@ -1,11 +1,6 @@
-import { createMemoryDocSnapshot, resolveMemoryDocs } from '../../core/memory-resolver.js';
+import { createMemoryDocSnapshot, readMemoryDocContent, resolveMemoryDocs } from '../../core/memory-resolver.js';
 import type { MemoryDoc } from '../../core/memory-resolver.js';
-export { createMemoryDocSnapshot, resolveMemoryDocs };
-/** Load the body at an already-resolved memory path with the same frontmatter
- * stripping and in-node path interpolation as `memory read`. Callers that
- * already have the resolved path (such as slash-command discovery) avoid
- * re-walking every memory store for each document. */
-export declare function readMemoryDocContent(path: string, includeFrontmatter?: boolean): string;
+export { createMemoryDocSnapshot, readMemoryDocContent, resolveMemoryDocs };
 /** One physical document sharing a canonical identity, as the path-aware
  *  surfaces report it. `--dir <its project>` is how a non-winner is reached. */
 export declare function candidateRow(doc: MemoryDoc, winner: MemoryDoc): Record<string, unknown>;

package/dist/commands/memory/read.js

@@ -1,12 +1,11 @@
+import { envNodeId } from '../../shared/env.js';
 import { CrtrClient } from '../../api/index.js';
-import { interpolateNodePaths } from '../../core/canvas/paths.js';
 import { defineLeaf } from '../../core/command.js';
 import { CrtrError } from '../../core/errors.js';
 import { memoryExtensionEffectiveCatalog, projectEffectiveMemoryExtensions } from '../../core/memory/extensions.js';
-import { readText, realpathOrSelf } from '../../core/fs-utils.js';
-import { parseFrontmatterGeneric } from '../../core/frontmatter.js';
+import { realpathOrSelf } from '../../core/fs-utils.js';
 import { docLinkNames } from '../../core/memory/doc-link-grammar.js';
-import { createMemoryDocSnapshot, listAllMemoryDocs, loadMemoryStoreView, resolveMemoryCandidates, resolveMemoryDocs, } from '../../core/memory-resolver.js';
+import { createMemoryDocSnapshot, listAllMemoryDocs, loadMemoryStoreView, readMemoryDocContent, resolveMemoryCandidates, resolveMemoryDocs, } from '../../core/memory-resolver.js';
 import { expandShellBlocks, hasShellBlocks, makeNodeShellRunner } from '../../core/runtime/shell-expansion.js';
 import { emptyContextExposureState, exposedAtOrAbove, exposureTarget, loadContextExposureState, registerDocumentExposure, registerExposure, saveContextExposureState, } from '../../core/substrate/injected-store.js';
 import { dirDedupKey, docListingDirs, docsByName, isDirName, renderDirListing } from '../../core/substrate/listings.js';
@@ -15,17 +14,7 @@ import { renderResult } from '../../core/render.js';
 import { effectiveDocKind } from '../../core/substrate/schema.js';
 import { canonicalSegments } from '../../core/memory/identity.js';
 import { MEMORY_KINDS, requireMountedStore, resolveReadSelector, selectorParam } from './shared.js';
-export { createMemoryDocSnapshot, resolveMemoryDocs };
-/** Load the body at an already-resolved memory path with the same frontmatter
- * stripping and in-node path interpolation as `memory read`. Callers that
- * already have the resolved path (such as slash-command discovery) avoid
- * re-walking every memory store for each document. */
-export function readMemoryDocContent(path, includeFrontmatter = false) {
-    const raw = readText(path);
-    const content = includeFrontmatter ? raw : parseFrontmatterGeneric(raw).body;
-    const nodeId = process.env['CRTR_NODE_ID'];
-    return nodeId ? interpolateNodePaths(content, nodeId) : content;
-}
+export { createMemoryDocSnapshot, readMemoryDocContent, resolveMemoryDocs };
 /** The node-config subject for memory-read-event gate evaluation. A CLI
  * process cannot take it from canvas-db (V-1); one `/v1` request supplies it.
  * With no node identity or no reachable daemon the answer is null — gated
@@ -150,7 +139,7 @@ export const readLeaf = defineLeaf({
             }
             fail = () => resolveMemoryCandidates(nameRaw, resolveOpts);
         }
-        const nodeId = process.env['CRTR_NODE_ID'] || undefined;
+        const nodeId = envNodeId() || undefined;
         if (set === null) {
             // No document answers this name — a directory with no document of its own
             // still does, through its listing. An explicit dir read is a deliberate

package/dist/commands/memory/shared.d.ts

@@ -194,7 +194,7 @@ export declare function overlayParam(name: string, overrides?: Partial<FlagParam
  *  `--doc-rationale`, because `--rationale` there means why THIS REVISION is
  *  happening. Same field, same prose, two flag names that cannot be confused. */
 export declare const DOC_RATIONALE_CONSTRAINT = "Frontmatter rationale \u2014 the observed agent failure that made this doc necessary. Maintainer-facing only: never ships in any delivered surface (boot render, on-read injection, `memory read` content), visible only via `memory read --frontmatter`. Omitting the flag preserves an existing rationale unchanged.";
-export declare const GUIDE_SURFACES = "Every doc appears in its directory\u2019s listing by default (suppress with --unlisted); everything beyond the listing is explicit `surfaces` routing \u2014 entries declaring WHEN the doc delivers and how much. Events: `boot` delivers in the boot catalog every agent sees; `workspace-open` delivers in first-message context when cwd/profile mounts the doc\u2019s project store (project stores only); `read` fires when the agent reads a matching file (globs vs the file\u2019s absolute path and basename, `./`-anchored globs vs its path relative to the store\u2019s owning repo dir, `match-frontmatter` predicates over the read file\u2019s own YAML frontmatter); `memory-read` fires when another memory doc is read (globs vs that doc\u2019s canonical name, `./` anchored to this doc\u2019s routing anchor \u2014 its own canonical name when it is its directory\u2019s document, otherwise the canonical directory it sits in); `command` fires when a matching shell command runs (globs vs each shell segment of the command line \u2014 split on `&&`/`||`/`;`/`|`/newlines outside quotes, leading `VAR=value` assignments dropped \u2014 where `*` spans whole whitespace-separated tokens and never part of one, `?` is one character inside a token, and quoted argument text is opaque, so `*git commit*` fires for `cd x && git commit -m \"\u2026\"` but not for `git commit-tree` or an `echo` that merely mentions it). An entry may also carry `gate`, a node-config predicate using the same vocabulary as the document-level `gate`: event constraints and entry gate both must match, then all participating entries fold to the highest `at` (`content` > `preview` > `name`), with no cross-entry deny precedence. The document-level `gate` remains the hard eligibility check: when it fails, no automatic surface can deliver the document. `at` sets how much delivers: `name` the bare tag, `preview` the routing line, `content` the whole body. Explicit `memory read` and listings remain deliberate access and ignore gates/rungs; only companion docs routed by their `memory-read` entries use entry gates. Each entry is paid by every future agent it fires on, so default down: no surfaces at all is correct for reference depth reached through listings and [[links]], and when a doc fits in a single sentence, deliver `content` directly \u2014 a `preview` routing line would run longer than the doc itself. Sentence-length `content` docs are correct; never pad a memory to be more verbose than the rule or fact it carries.";
+export declare const GUIDE_SURFACES = "Every doc appears in its directory\u2019s listing by default (suppress with --unlisted); everything beyond the listing is explicit `surfaces` routing \u2014 entries declaring WHEN the doc delivers and how much. Events: `boot` delivers in the boot catalog every agent sees; `workspace-open` delivers in first-message context when cwd/profile mounts the doc\u2019s project store (project stores only); `read` fires when the agent reads a matching file (globs vs the file\u2019s absolute path and basename, `./`-anchored globs vs its path relative to the store\u2019s owning repo dir, `match-frontmatter` predicates over the read file\u2019s own YAML frontmatter); `memory-read` fires when another memory doc is read (globs vs that doc\u2019s canonical name, `./` anchored to this doc\u2019s routing anchor \u2014 its own canonical name when it is its directory\u2019s document, otherwise the canonical directory it sits in); `command` fires when a matching shell command runs (globs vs each shell segment of the command line \u2014 split on `&&`/`||`/`;`/`|`/newlines outside quotes, leading `VAR=value` assignments dropped \u2014 where `*` spans whole whitespace-separated tokens and never part of one, `?` is one character inside a token, and quoted argument text is opaque, so `*git commit*` fires for `cd x && git commit -m \"\u2026\"` but not for `git commit-tree` or an `echo` that merely mentions it); `pre-command` fires BEFORE a matching bash command runs (same matching): when the memory has not been read yet, the command does not execute \u2014 the memory comes back as the tool result instead, and the agent re-issues the command, which then runs. Use it to guarantee a memory is seen before a sensitive action is taken. Requires `match`. An entry may also carry `gate`, a node-config predicate using the same vocabulary as the document-level `gate`: event constraints and entry gate both must match, then all participating entries fold to the highest `at` (`content` > `preview` > `name`), with no cross-entry deny precedence. The document-level `gate` remains the hard eligibility check: when it fails, no automatic surface can deliver the document. `at` sets how much delivers: `name` the bare tag, `preview` the routing line, `content` the whole body. Explicit `memory read` and listings remain deliberate access and ignore gates/rungs; only companion docs routed by their `memory-read` entries use entry gates. Each entry is paid by every future agent it fires on, so default down: no surfaces at all is correct for reference depth reached through listings and [[links]], and when a doc fits in a single sentence, deliver `content` directly \u2014 a `preview` routing line would run longer than the doc itself. Sentence-length `content` docs are correct; never pad a memory to be more verbose than the rule or fact it carries.";
 export declare const GUIDE_ROUTING_LINE = "The routing line (--when-and-why-to-read) is the only text an agent reads before deciding to load the doc. The test for its when-clause: it names an observable circumstance in the reader\u2019s current work, not the doc\u2019s topic reworded as an activity. If the WHEN can be inferred from the title alone, it is not a real trigger. Bad on a todo list: \"When planning or prioritizing work across this profile.\" Good: \"When the user mentions something from their todos, or asks what is still outstanding across this profile.\" The test for its because-clause: if it can be derived by paraphrasing the doc\u2019s advice, it is a restatement, not a payoff \u2014 a real payoff names a consequence in the reader\u2019s world that the document itself never asserts. Bad: \"because only genuine first principles belong in taste memory.\" Bad: \"because keeping the test loop fast and free of speculative tests protects the development pace\" \u2014 the doc\u2019s rule as an outcome, derivable straight from its advice. Good: \"because identifying throughlines in user taste lets future decisions be made faster and with less re-litigation.\" Someone mid-task who has not read the doc must be able to decide from this line alone whether the read is worth it. If you cannot name the concrete situation that triggers it, you do not yet understand the memory \u2014 ask the user one sharp question instead of improvising.";
 export declare const GUIDE_PREDICATE_VOCABULARY = "Document gates, surface-entry gates, and match-frontmatter share the same predicate language: a field map is AND-ed across fields; dotted fields resolve nested values; field matchers may be scalar, array, or object. Scalar matchers do exact equality, with arrays matching any element. Array matchers do membership or intersection. Object matchers accept `eq`, `ne`, `in`, `nin`, `exists`, `contains`, `containsAll`, `containsAny`, `matches`, `imatches`, `gt`, `gte`, `lt`, and `lte`. Combinators are `all`, `any`, and `not`; sibling field matchers next to them are AND-ed in. An empty condition is inert. An unknown op never matches.";
 export declare const GUIDE_DOC_LINKS = "Link related docs with `[[canonical/name]]`. A doc link in any body is a first-class cross-reference to another memory document by its exact canonical name \u2014 the same identifier `crtr memory read` takes, namespace included for a project document. A bare directory name is a valid link too: following it returns that directory\u2019s own document when it has one, plus the directory listing. Links are pointers, never transclusion: the linked body is loaded only when a reader follows it, so a link costs nothing until needed. `crtr memory lint` fails on a link that resolves to no document or directory, and `crtr memory read` lists a doc\u2019s resolvable links alongside its body. There is no alias, label, or old-name form \u2014 a renamed target needs its links rewritten.";

package/dist/commands/memory/shared.js

@@ -3,6 +3,7 @@
 // scope modules and build their documented output objects on top of the small
 // helpers here. Nothing in this file forks on kind or re-implements the
 // schema/gate/resolver — it only composes them.
+import { envNodeId, envProfileId } from '../../shared/env.js';
 import { existsSync, readdirSync, realpathSync, rmdirSync, statSync } from 'node:fs';
 import { dirname, join, resolve as resolvePath } from 'node:path';
 import { stringify as yamlStringify, parse as yamlParse } from 'yaml';
@@ -40,7 +41,7 @@ export function scopeRank(scope) {
     return scope === 'node' ? -1 : scope === 'project' ? 0 : scope === 'profile' ? 1 : scope === 'user' ? 2 : 3;
 }
 export function registerMemoryListingExposure(identity) {
-    const nodeId = process.env['CRTR_NODE_ID'];
+    const nodeId = envNodeId();
     if (nodeId === undefined || nodeId === '')
         return;
     const state = loadContextExposureState(nodeId);
@@ -151,7 +152,7 @@ export function resolveWriteSelector(input) {
     if (scope === 'node') {
         // The this-node store: the same dir render.ts's nodeLocalDocs loads at
         // boot, so a doc written here rides into this node's knowledge block.
-        const nodeId = process.env['CRTR_NODE_ID'] || '';
+        const nodeId = envNodeId() || '';
         if (nodeId === '') {
             throw usage('node scope requires a running node (CRTR_NODE_ID unset); rerun inside a node');
         }
@@ -163,7 +164,7 @@ export function resolveWriteSelector(input) {
         // is a durable id this process was launched under, so it resolves strictly
         // — a stale one must fail rather than write into a neighbouring store.
         const typed = input.profile !== undefined && input.profile !== '';
-        const profileIdOrName = typed ? input.profile : process.env['CRTR_PROFILE_ID'] || '';
+        const profileIdOrName = typed ? input.profile : envProfileId() || '';
         if (profileIdOrName === '') {
             throw usage('profile scope requires a selected profile; rerun inside a profiled node or pass --profile');
         }
@@ -209,14 +210,12 @@ export function requireMountedStore(store) {
         next: `Run \`crtr sys migrate --dir ${repositoryRoot}\`.`,
     });
 }
-// ---------------------------------------------------------------------------
 // Canonical name → physical placement
 //
 // Every surface takes the FULL canonical name. Placement strips the selected
 // store's namespace off it, checks that neither the identity nor either
 // physical representation of the local name is already taken, and picks the
 // form the new file takes.
-// ---------------------------------------------------------------------------
 /** Normalize and validate a full canonical name: ordering prefixes are
  *  physical-path-only, a trailing `INDEX` is never an address, and the segment
  *  charset is fixed. */
@@ -436,7 +435,7 @@ export function coerceSurface(raw) {
             throw usage(`--surface: invalid \`match-frontmatter\`: ${JSON.stringify(matchFrontmatter)} (expected a field→matcher object)`);
         }
     }
-    if ((on === 'read' || on === 'memory-read' || on === 'command') && match === undefined && matchFrontmatter === undefined) {
+    if ((on === 'read' || on === 'memory-read' || on === 'command' || on === 'pre-command') && match === undefined && matchFrontmatter === undefined) {
         throw usage(`--surface: a \`${on}\` entry requires \`match\`${on === 'read' ? ' or `match-frontmatter`' : ''}`);
     }
     const gate = rec['gate'];
@@ -709,13 +708,11 @@ export function applyExtensionChanges(frontmatter, sets, unsets) {
     else
         frontmatter['extensions'] = extensions;
 }
-// ---------------------------------------------------------------------------
 // Help material shared by `write` and `edit`
 //
 // Single-sourced: both leaves compose these, so a wording fix lands on both.
 // Anything exclusive to one leaf (creation rules on `write`, the rationale
 // contract on `edit`) stays owned by that leaf.
-// ---------------------------------------------------------------------------
 /** The frontmatter-overlay flags, keyed by flag name, carrying the prose true
  *  on BOTH leaves. `write` appends its creation clauses with `withConstraint`;
  *  neither leaf restates the other's rules. */
@@ -768,7 +765,7 @@ export const FRONTMATTER_OVERLAY_PARAMS = {
     'when-and-why-to-read': { kind: 'flag', name: 'when-and-why-to-read', type: 'string', required: false, constraint: 'ONE routing sentence: "When <circumstance>, this <kind> should be read because <broader downstream payoff>." WHY is the reader\u2019s payoff \u2014 the consequence they secure for their task by reading \u2014 NEVER the doc summary, its rule, or that rule reworded as an outcome (a benefit-shaped restatement still fails). Rendered verbatim as the preview.' },
     'short-form': { kind: 'flag', name: 'short-form', type: 'string', required: false, constraint: 'Frontmatter short-form \u2014 a very abbreviated version of the content, the hook shown in `crtr memory list`.' },
     'unlisted': { kind: 'flag', name: 'unlisted', type: 'bool', required: false, default: false, constraint: 'Suppress this doc from directory listings. Suppression only — explicit reads, [[links]], and surfaces entries still work.' },
-    'surface': { kind: 'flag', name: 'surface', type: 'string', required: false, repeatable: true, constraint: 'One routing entry per occurrence, as a YAML/JSON object `{on, at, match?, match-frontmatter?, gate?}`; the flag set replaces the document’s whole surfaces list. `on` is boot|workspace-open|read|memory-read|command; `at` is name|preview|content. `match` holds the event’s globs — required on read/memory-read/command (a read entry may carry `match-frontmatter`, a predicate over the read file’s own frontmatter, instead), meaningless on boot/workspace-open. Optional entry `gate` is a node-config predicate using the same vocabulary as the document gate; its event constraints and gate both match before it participates. A `./`-anchored glob is relative: for `read` to the store’s owning repo dir, for `memory-read` to this doc’s routing anchor — its own canonical name when the doc is its directory’s document (`<dir>/INDEX.md`), otherwise the canonical directory it sits in. Participating entries fold to their highest `at`; there is no cross-entry deny precedence.' },
+    'surface': { kind: 'flag', name: 'surface', type: 'string', required: false, repeatable: true, constraint: 'One routing entry per occurrence, as a YAML/JSON object `{on, at, match?, match-frontmatter?, gate?}`; the flag set replaces the document’s whole surfaces list. `on` is boot|workspace-open|read|memory-read|command|pre-command; `at` is name|preview|content. `match` holds the event’s globs — required on read/memory-read/command/pre-command (a read entry may carry `match-frontmatter`, a predicate over the read file’s own frontmatter, instead), meaningless on boot/workspace-open. Optional entry `gate` is a node-config predicate using the same vocabulary as the document gate; its event constraints and gate both match before it participates. A `./`-anchored glob is relative: for `read` to the store’s owning repo dir, for `memory-read` to this doc’s routing anchor — its own canonical name when the doc is its directory’s document (`<dir>/INDEX.md`), otherwise the canonical directory it sits in. Participating entries fold to their highest `at`; there is no cross-entry deny precedence.' },
     'gate': { kind: 'flag', name: 'gate', type: 'string', required: false, constraint: 'Frontmatter gate \u2014 YAML/JSON object predicate over node config using the same field/matcher vocabulary described in the guide.' },
     'slash': { kind: 'flag', name: 'slash', type: 'bool', required: false, default: false, constraint: 'Presence flags this doc invocable as a pi slash command (`/<name>`, `/` in a nested name rendered as `:`) \u2014 the doc body becomes the command\u2019s injected prompt. Default false: most docs are consulted, not invoked.' },
 };
@@ -786,7 +783,7 @@ export function overlayParam(name, overrides = {}, extraConstraint) {
  *  `--doc-rationale`, because `--rationale` there means why THIS REVISION is
  *  happening. Same field, same prose, two flag names that cannot be confused. */
 export const DOC_RATIONALE_CONSTRAINT = 'Frontmatter rationale \u2014 the observed agent failure that made this doc necessary. Maintainer-facing only: never ships in any delivered surface (boot render, on-read injection, `memory read` content), visible only via `memory read --frontmatter`. Omitting the flag preserves an existing rationale unchanged.';
-export const GUIDE_SURFACES = 'Every doc appears in its directory’s listing by default (suppress with --unlisted); everything beyond the listing is explicit `surfaces` routing — entries declaring WHEN the doc delivers and how much. Events: `boot` delivers in the boot catalog every agent sees; `workspace-open` delivers in first-message context when cwd/profile mounts the doc’s project store (project stores only); `read` fires when the agent reads a matching file (globs vs the file’s absolute path and basename, `./`-anchored globs vs its path relative to the store’s owning repo dir, `match-frontmatter` predicates over the read file’s own YAML frontmatter); `memory-read` fires when another memory doc is read (globs vs that doc’s canonical name, `./` anchored to this doc’s routing anchor — its own canonical name when it is its directory’s document, otherwise the canonical directory it sits in); `command` fires when a matching shell command runs (globs vs each shell segment of the command line — split on `&&`/`||`/`;`/`|`/newlines outside quotes, leading `VAR=value` assignments dropped — where `*` spans whole whitespace-separated tokens and never part of one, `?` is one character inside a token, and quoted argument text is opaque, so `*git commit*` fires for `cd x && git commit -m "…"` but not for `git commit-tree` or an `echo` that merely mentions it). An entry may also carry `gate`, a node-config predicate using the same vocabulary as the document-level `gate`: event constraints and entry gate both must match, then all participating entries fold to the highest `at` (`content` > `preview` > `name`), with no cross-entry deny precedence. The document-level `gate` remains the hard eligibility check: when it fails, no automatic surface can deliver the document. `at` sets how much delivers: `name` the bare tag, `preview` the routing line, `content` the whole body. Explicit `memory read` and listings remain deliberate access and ignore gates/rungs; only companion docs routed by their `memory-read` entries use entry gates. Each entry is paid by every future agent it fires on, so default down: no surfaces at all is correct for reference depth reached through listings and [[links]], and when a doc fits in a single sentence, deliver `content` directly — a `preview` routing line would run longer than the doc itself. Sentence-length `content` docs are correct; never pad a memory to be more verbose than the rule or fact it carries.';
+export const GUIDE_SURFACES = 'Every doc appears in its directory’s listing by default (suppress with --unlisted); everything beyond the listing is explicit `surfaces` routing — entries declaring WHEN the doc delivers and how much. Events: `boot` delivers in the boot catalog every agent sees; `workspace-open` delivers in first-message context when cwd/profile mounts the doc’s project store (project stores only); `read` fires when the agent reads a matching file (globs vs the file’s absolute path and basename, `./`-anchored globs vs its path relative to the store’s owning repo dir, `match-frontmatter` predicates over the read file’s own YAML frontmatter); `memory-read` fires when another memory doc is read (globs vs that doc’s canonical name, `./` anchored to this doc’s routing anchor — its own canonical name when it is its directory’s document, otherwise the canonical directory it sits in); `command` fires when a matching shell command runs (globs vs each shell segment of the command line — split on `&&`/`||`/`;`/`|`/newlines outside quotes, leading `VAR=value` assignments dropped — where `*` spans whole whitespace-separated tokens and never part of one, `?` is one character inside a token, and quoted argument text is opaque, so `*git commit*` fires for `cd x && git commit -m "…"` but not for `git commit-tree` or an `echo` that merely mentions it); `pre-command` fires BEFORE a matching bash command runs (same matching): when the memory has not been read yet, the command does not execute — the memory comes back as the tool result instead, and the agent re-issues the command, which then runs. Use it to guarantee a memory is seen before a sensitive action is taken. Requires `match`. An entry may also carry `gate`, a node-config predicate using the same vocabulary as the document-level `gate`: event constraints and entry gate both must match, then all participating entries fold to the highest `at` (`content` > `preview` > `name`), with no cross-entry deny precedence. The document-level `gate` remains the hard eligibility check: when it fails, no automatic surface can deliver the document. `at` sets how much delivers: `name` the bare tag, `preview` the routing line, `content` the whole body. Explicit `memory read` and listings remain deliberate access and ignore gates/rungs; only companion docs routed by their `memory-read` entries use entry gates. Each entry is paid by every future agent it fires on, so default down: no surfaces at all is correct for reference depth reached through listings and [[links]], and when a doc fits in a single sentence, deliver `content` directly — a `preview` routing line would run longer than the doc itself. Sentence-length `content` docs are correct; never pad a memory to be more verbose than the rule or fact it carries.';
 export const GUIDE_ROUTING_LINE = 'The routing line (--when-and-why-to-read) is the only text an agent reads before deciding to load the doc. The test for its when-clause: it names an observable circumstance in the reader\u2019s current work, not the doc\u2019s topic reworded as an activity. If the WHEN can be inferred from the title alone, it is not a real trigger. Bad on a todo list: "When planning or prioritizing work across this profile." Good: "When the user mentions something from their todos, or asks what is still outstanding across this profile." The test for its because-clause: if it can be derived by paraphrasing the doc\u2019s advice, it is a restatement, not a payoff \u2014 a real payoff names a consequence in the reader\u2019s world that the document itself never asserts. Bad: "because only genuine first principles belong in taste memory." Bad: "because keeping the test loop fast and free of speculative tests protects the development pace" \u2014 the doc\u2019s rule as an outcome, derivable straight from its advice. Good: "because identifying throughlines in user taste lets future decisions be made faster and with less re-litigation." Someone mid-task who has not read the doc must be able to decide from this line alone whether the read is worth it. If you cannot name the concrete situation that triggers it, you do not yet understand the memory \u2014 ask the user one sharp question instead of improvising.';
 export const GUIDE_PREDICATE_VOCABULARY = 'Document gates, surface-entry gates, and match-frontmatter share the same predicate language: a field map is AND-ed across fields; dotted fields resolve nested values; field matchers may be scalar, array, or object. Scalar matchers do exact equality, with arrays matching any element. Array matchers do membership or intersection. Object matchers accept `eq`, `ne`, `in`, `nin`, `exists`, `contains`, `containsAll`, `containsAny`, `matches`, `imatches`, `gt`, `gte`, `lt`, and `lte`. Combinators are `all`, `any`, and `not`; sibling field matchers next to them are AND-ed in. An empty condition is inert. An unknown op never matches.';
 export const GUIDE_DOC_LINKS = 'Link related docs with `[[canonical/name]]`. A doc link in any body is a first-class cross-reference to another memory document by its exact canonical name \u2014 the same identifier `crtr memory read` takes, namespace included for a project document. A bare directory name is a valid link too: following it returns that directory\u2019s own document when it has one, plus the directory listing. Links are pointers, never transclusion: the linked body is loaded only when a reader follows it, so a link costs nothing until needed. `crtr memory lint` fails on a link that resolves to no document or directory, and `crtr memory read` lists a doc\u2019s resolvable links alongside its body. There is no alias, label, or old-name form \u2014 a renamed target needs its links rewritten.';

package/dist/commands/memory/write.js

@@ -1,3 +1,4 @@
+import { envNodeId, envProfileId } from '../../shared/env.js';
 import { join } from 'node:path';
 import { defineLeaf } from '../../core/command.js';
 import { usage } from '../../core/errors.js';
@@ -188,14 +189,14 @@ export const writeLeaf = defineLeaf({
                 ? {
                     resolvable: resolvableCanonicalNames(loadMemoryTargetView({
                         cwd: store.ownerDir ?? process.cwd(),
-                        profileId: process.env['CRTR_PROFILE_ID'] || null,
-                        nodeId: process.env['CRTR_NODE_ID'] || null,
+                        profileId: envProfileId() || null,
+                        nodeId: envNodeId() || null,
                     }, { quiet: true, includeDescendants: true }).docs),
                 }
                 : {}),
             ...(carriesBootEntry
                 ? {
-                    nestedStore: descendantStoreRoots(projectScopeRoots(process.cwd(), process.env['CRTR_PROFILE_ID'] || null))
+                    nestedStore: descendantStoreRoots(projectScopeRoots(process.cwd(), envProfileId() || null))
                         .map((root) => realpathOrSelf(join(root, 'memory')))
                         .includes(realpathOrSelf(memoryDir)),
                 }

package/dist/commands/node/bash.js

@@ -1,4 +1,5 @@
 // `crtr node bash` — file-backed background job controls.
+import { envNodeId } from '../../shared/env.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { displayMessage } from '../../core/runtime/tmux-chrome.js';
@@ -12,7 +13,7 @@ function resolveBashTarget(input, missingMessage) {
     if (id === undefined || id === '')
         id = nodeInPane(pane);
     if (id === undefined || id === '')
-        id = process.env['CRTR_NODE_ID'];
+        id = envNodeId();
     if (id === undefined || id === '') {
         throw new InputError({ error: 'no_node', message: missingMessage, next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
     }

package/dist/commands/node/create.js

@@ -1,4 +1,5 @@
 // `crtr node new` — creation commands and persona-kind helpers.
+import { envNodeId } from '../../shared/env.js';
 import { defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { mark } from '../../core/timing.js';
@@ -207,7 +208,7 @@ async function runNodeCreation(input) {
     if (noKickoff && mode === 'orchestrator') {
         throw new InputError({ error: 'no_kickoff_orchestrator_unsupported', message: '--no-kickoff cannot be combined with --mode orchestrator', field: 'no-kickoff', next: 'Drop --no-kickoff and provide a prompt, or spawn in base mode.' });
     }
-    const parentId = parent ?? process.env['CRTR_NODE_ID'];
+    const parentId = parent ?? envNodeId();
     mark('node_new.create_start', { root });
     const detail = await cliClient().createNode({
         ...(kind !== undefined ? { kind } : {}),

package/dist/commands/node/inspect.js

@@ -89,9 +89,7 @@ const nodeList = defineLeaf({
         return { nodes };
     },
 });
-// ---------------------------------------------------------------------------
 // node inspect show — a node + its place in the spine
-// ---------------------------------------------------------------------------
 // The renderer receives only the command result, while JSON output bypasses it.
 // Keep remote provenance out of the returned DTO-shaped object without adding a
 // second wire field or mutating the remote response.
@@ -233,9 +231,7 @@ const nodeShow = defineLeaf({
         return parts.join('\n\n');
     },
 });
-// ---------------------------------------------------------------------------
 // node fork — branch a conversation + durable context into an idle root
-// ---------------------------------------------------------------------------
 export const nodeFork = defineLeaf({
     name: 'fork',
     description: 'fork a node into an independent idle root with the same conversation and durable context',
@@ -287,9 +283,7 @@ export const nodeFork = defineLeaf({
         return `Forked independent idle root ${result['node_id']}.${placement} It will make no model call until its first real user message.`;
     },
 });
-// ---------------------------------------------------------------------------
 // node inspect — read the graph (list, show, context)
-// ---------------------------------------------------------------------------
 export const nodeInspect = defineBranch({
     name: 'inspect',
     description: 'read one node — its graph position, context, and artifacts',

package/dist/commands/node/lifecycle.js

@@ -1,4 +1,5 @@
 // `crtr node` lifecycle and durable configuration commands.
+import { envNodeId } from '../../shared/env.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { cliClient, getNodeOrNull, rethrowAsCliError } from '../api-client.js';
@@ -65,9 +66,7 @@ const nodeRecycle = defineLeaf({
         return lines.join('\n');
     },
 });
-// ---------------------------------------------------------------------------
 // node lifecycle close — close a node + cascade-cancel its exclusive subtree (Alt+C → x)
-// ---------------------------------------------------------------------------
 const nodeClose = defineLeaf({
     name: 'close',
     description: 'close a node + cascade-cancel its exclusive subtree (revivable)',
@@ -110,9 +109,7 @@ const nodeClose = defineLeaf({
         return `Closed ${r['node_id']} and its exclusive subtree — ${r['count']} node(s) closed${spared > 0 ? `, ${spared} spared (still managed from outside the subtree)` : ''}.`;
     },
 });
-// ---------------------------------------------------------------------------
 // node config — reconfigure a node's settings headlessly (model/lifecycle/kind/mode/name)
-// ---------------------------------------------------------------------------
 const NODE_CONFIG_MODEL_EFFECT = 'Model change first: a live broker switches immediately over its socket; a dormant node persists the durable model override and launch recipe for its next revive.';
 export const nodeConfig = defineLeaf({
     name: 'config',
@@ -268,7 +265,7 @@ export const nodePromote = defineLeaf({
         effects: ['Flips mode→orchestrator + kind→chosen (lifecycle unchanged unless --resident, which also flips lifecycle→resident); --model durably pins the model tier; rewrites the launch spec to that kind\'s orchestrator persona; seeds context/roadmap.md scaffold if absent.', 'The next model request is gated on appending and persisting your new-role guidance. If a fresh context starts first, its rebuilt baseline carries the new role.'],
     },
     run: async (input) => {
-        const id = input['node'] ?? process.env['CRTR_NODE_ID'];
+        const id = input['node'] ?? envNodeId();
         if (id === undefined || id === '')
             throw new InputError({ error: 'no_node', message: 'no node to promote (set CRTR_NODE_ID or pass --node)', next: 'Run from inside a node, or pass --node <id>.' });
         const kind = input['kind'];
@@ -300,7 +297,7 @@ async function resolveLifecycleNode(input, pane) {
     if (id === undefined || id === '')
         id = nodeInPane(pane);
     if (id === undefined || id === '')
-        id = process.env['CRTR_NODE_ID'];
+        id = envNodeId();
     if (id === undefined || id === '')
         throw new InputError({ error: 'no_node', message: 'no node (set CRTR_NODE_ID, pass --node, or run from the agent\'s pane)', next: 'Run from inside a node, pass --node <id>, or --pane <pane>.' });
     const exists = await getNodeOrNull(id);
@@ -308,13 +305,11 @@ async function resolveLifecycleNode(input, pane) {
         throw new InputError({ error: 'not_found', message: `no node: ${id}`, next: 'List nodes with `crtr node inspect list`.' });
     return id;
 }
-// ---------------------------------------------------------------------------
 // node lifecycle demote — flip a node to TERMINAL in place (the friendly half
 // of the promote/demote pair; bound to Alt+C → d, and → D with --detach). It
 // stays focused and running but now owes a final up the spine. `node config
 // --lifecycle` remains the orthogonal low-level command (it also does resident).
 // See vision F5.
-// ---------------------------------------------------------------------------
 const nodeDemote = defineLeaf({
     name: 'demote',
     description: 'demote a node to terminal in place; it stays focused and running but now owes a final; --detach also closes its viewer (broker keeps running off-screen)',
@@ -352,9 +347,7 @@ const nodeDemote = defineLeaf({
     },
     render: (r) => `Demoted ${r['node_id']} — lifecycle now terminal (in place)${r['detached'] === true ? ', viewer closed (broker still running off-screen)' : ''}.`,
 });
-// ---------------------------------------------------------------------------
 // node lifecycle — recycle, close, or demote a node
-// ---------------------------------------------------------------------------
 export const nodeLifecycle = defineBranch({
     name: 'lifecycle',
     description: 'lifecycle actions — recycle, close, demote, or revive a node',
@@ -365,9 +358,7 @@ export const nodeLifecycle = defineBranch({
     },
     children: [nodeRecycle, nodeClose, nodeDemote, nodeReviveLeaf],
 });
-// ---------------------------------------------------------------------------
 // node yield — refresh: discard context, revive fresh in the same mode against roadmap or goal
-// ---------------------------------------------------------------------------
 export const nodeYield = defineLeaf({
     name: 'yield',
     description: 'refresh your context, same mode, against your roadmap or goal',
@@ -395,7 +386,7 @@ export const nodeYield = defineLeaf({
         effects: ['The stophook shuts the process down on next stop and the daemon revives it fresh.', '--kind and/or --model durably reshape the node (kind respecialization, model-tier pin) before the refresh-revive; --promote additionally flips mode→orchestrator and seeds a roadmap scaffold — mode is otherwise left exactly as it was.'],
     },
     run: async (input) => {
-        const id = process.env['CRTR_NODE_ID'];
+        const id = envNodeId();
         if (id === undefined || id === '')
             throw new InputError({ error: 'no_node', message: 'no node to yield (CRTR_NODE_ID unset)', next: 'Run from inside a node.' });
         const kind = input['kind'];

package/dist/commands/node/message.js

@@ -1,4 +1,5 @@
 // `crtr node message` — immediate inbox delivery and typed-output requests.
+import { envNodeId } from '../../shared/env.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { OUTPUT_SCHEMA_CONSTRAINTS, OUTPUT_SCHEMA_TRANSPORT, parseOutputSchemaValue } from '../../core/runtime/structured-output.js';
@@ -22,7 +23,7 @@ async function resolveMsgTarget(input) {
         });
     }
     if (self) {
-        const id = process.env['CRTR_NODE_ID'];
+        const id = envNodeId();
         if (id === undefined || id === '') {
             throw new InputError({ error: 'no_node', message: 'no node to target with --self (CRTR_NODE_ID unset)', next: 'Run from inside a node, or pass --to <node-id>.' });
         }
@@ -80,7 +81,7 @@ async function runMessageEngine(input) {
     if (outputSchema !== null && tierRaw === 'deferred') {
         throw new InputError({ error: 'output_schema_deferred_tier', message: '--output-schema cannot combine with --tier deferred because the target must answer', field: 'tier', next: 'Use normal, urgent, or critical tier, or drop --output-schema.' });
     }
-    const senderFrom = process.env['CRTR_NODE_ID'];
+    const senderFrom = envNodeId();
     const client = cliClient();
     if (!hasBody && !hasSituational && outputSchema === null) {
         throw new InputError({ error: 'empty_body', message: 'a message body is required unless --output-schema or --situational-context is supplied', field: 'body', next: 'Pass the message on stdin, or supply one of the documented alternatives.' });

package/dist/commands/node/subscription.js

@@ -1,9 +1,10 @@
 // `crtr node subscription` — push-delivery edge controls.
+import { envNodeId } from '../../shared/env.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { cliClient, rethrowAsCliError } from '../api-client.js';
 function resolveSubscriber(input) {
-    const sub = input['subscriber'] ?? process.env['CRTR_NODE_ID'];
+    const sub = input['subscriber'] ?? envNodeId();
     if (sub === undefined || sub === '') {
         throw new InputError({ error: 'no_subscriber', message: 'no subscriber (set CRTR_NODE_ID or pass --subscriber)', field: 'subscriber', next: 'Run from inside a node, or pass --subscriber <id>.' });
     }

package/dist/commands/node/wait.js

@@ -1,11 +1,12 @@
 // `crtr node wait` — durable controller and deadline waits.
+import { envNodeId, envProfileId } from '../../shared/env.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { parseWhen } from '../../core/wake.js';
 import { cliClient, getNodeOrNull, rethrowAsCliError } from '../api-client.js';
 import { shellQuote } from '../surface/node/placement.js';
 function armerId() {
-    const id = process.env['CRTR_NODE_ID'];
+    const id = envNodeId();
     if (id === undefined || id === '') {
         throw new InputError({ error: 'no_node', message: 'no node to anchor a deadline cron (CRTR_NODE_ID unset)', next: 'Run from inside a node.' });
     }
@@ -84,7 +85,7 @@ const nodeWaitDeadline = defineLeaf({
         const parsed = parseWhen(until, parseOpts(now, tz));
         if ('error' in parsed)
             throwTimeError(parsed.error);
-        const profile = process.env['CRTR_PROFILE_ID'];
+        const profile = envProfileId();
         // One deadline per node: the arm seam REPLACES this node's pending
         // cancel-on-wake cron rather than stacking a second one (see armCron in
         // core/canvas/crons.ts, where the invariant is enforced for every caller).
@@ -129,7 +130,7 @@ const nodeWait = defineLeaf({
         effects: ['Durably records the controller on this node. The stop guard permits dormancy only while that controller remains active or idle; its next inbox delivery clears the record before the delivery wakes this node.'],
     },
     run: async (input) => {
-        const nodeId = process.env['CRTR_NODE_ID'];
+        const nodeId = envNodeId();
         if (nodeId === undefined || nodeId === '')
             throw new InputError({ error: 'no_node', message: 'no node to wait (CRTR_NODE_ID unset)', next: 'Run from inside the terminal node that is blocked.' });
         const node = await getNodeOrNull(nodeId);

package/dist/commands/node-context.js

@@ -17,6 +17,7 @@
 // and the on-disk existence filter is a local fs read (neither touches canvas
 // state). The /context popup (src/pi-extensions/canvas-context.ts) shells this
 // leaf inside a tmux display-popup. Piped / non-TTY it prints the roster.
+import { envNodeId } from '../shared/env.js';
 import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -106,7 +107,7 @@ export const nodeContextLeaf = defineLeaf({
         ],
     },
     run: async (input) => {
-        const selfId = input['node']?.trim() || process.env['CRTR_NODE_ID'];
+        const selfId = input['node']?.trim() || envNodeId();
         if (selfId === undefined || selfId === '') {
             throw new InputError({
                 error: 'no_node',

package/dist/commands/node-lifecycle-revive.js

@@ -52,9 +52,7 @@ export function isNowEligibleFault(fault) {
         return true;
     return fault.retry.by === 'daemon';
 }
-// ---------------------------------------------------------------------------
 // Local, db-free helpers (inlined so the leaf never imports the canvas barrel)
-// ---------------------------------------------------------------------------
 /** Inlined from `runtime/busy.ts` (which reaches the canvas barrel via `jobDir`):
  * is the node mid-turn right now? `<jobDir>/busy` exists for the span pi is
  * inside a run. `jobDir` here is the pure path helper from paths.js. */

package/dist/commands/node-worktree.js

@@ -2,12 +2,13 @@
 // `node new --worktree <base>`; this branch holds the single close
 // verb, symmetric with birth, so a git worktree's whole lifecycle sits under
 // `node`.
+import { envNodeId } from '../shared/env.js';
 import { defineBranch, defineLeaf } from '../core/command.js';
 import { InputError } from '../core/io.js';
 import { ApiError } from '../api/index.js';
 import { cliClient } from './api-client.js';
 function requireCallerNode() {
-    const id = process.env['CRTR_NODE_ID'];
+    const id = envNodeId();
     if (id === undefined || id.trim() === '') {
         throw new InputError({
             error: 'no_node_context',

package/dist/commands/pkg/browse/actions.d.ts

@@ -1,4 +1,4 @@
-import type { ActionPresentation, ActionRequest, ActionOutcome } from "./model.js";
+import type { ActionPresentation, ActionRequest, ActionOutcome } from './model.js';
 /** How an action reads before it runs — and whether it needs confirming. */
 export declare function presentAction(request: ActionRequest): ActionPresentation;
 /** Actions available for a request's subject right now, in offer order. */

package/dist/commands/pkg/browse/actions.js

@@ -1,9 +1,9 @@
 // Mutations for `crtr pkg browse`. Each action delegates to the same leaf the
 // CLI runs, so the browser and `crtr pkg …` can never drift.
-import { marketAdd, marketRemove, marketUpdate } from "../market-manage.js";
-import { pluginDisable, pluginEnable, pluginInstall, pluginRemove, pluginUpdate, } from "../plugin-manage.js";
-import { listAllMarketplaces } from "../../../core/resolver.js";
-import { projectScopeRoot } from "../../../core/scope.js";
+import { marketAdd, marketRemove, marketUpdate } from '../market-manage.js';
+import { pluginDisable, pluginEnable, pluginInstall, pluginRemove, pluginUpdate, } from '../plugin-manage.js';
+import { listAllMarketplaces } from '../../../core/resolver.js';
+import { projectScopeRoot } from '../../../core/scope.js';
 function pluginName(request) {
     return request.entry?.name ?? "plugin";
 }

package/dist/commands/pkg/browse/catalog.d.ts

@@ -1,4 +1,4 @@
-import { type Catalog, type PluginCapability, type PluginEntry } from "./model.js";
+import { type Catalog, type PluginCapability, type PluginEntry } from './model.js';
 /** Every rail source with its rows: the installed library first, then each
  *  registered marketplace. Called on open and after any action that could
  *  change install state. Must never throw for a broken marketplace — record it

package/dist/commands/pkg/browse/catalog.js

@@ -1,20 +1,20 @@
 // Catalog reads for `crtr pkg browse`. Everything here is read-only; mutations
 // live in actions.ts.
-import { statSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
-import { SUBTREE_NAMES, coreCommandPaths } from "../../../build-root.js";
-import { discoverPluginCommandCandidates, validateEffectiveCommandPlugins, validatePluginCommands } from "../../../core/command-plugins/discovery.js";
-import { qualifiedTopLevelCommandName } from "../../../core/command-manifests/registry.js";
-import { listDirs, pathExists, walkFiles } from "../../../core/fs-utils.js";
-import { currentSha, gitSync } from "../../../core/git.js";
-import { listPluginMemoryDocs } from "../../../core/memory-resolver.js";
-import { memoryExtensionEffectiveCatalog, projectEffectiveMemoryExtensions } from "../../../core/memory/extensions.js";
-import { readMarketplaceManifest, readPluginManifest } from "../../../core/manifest.js";
-import { readConfig } from "../../../core/config.js";
-import { parseSubstrateDoc } from "../../../core/substrate/schema.js";
-import { projectScopeRoot, userScopeRoot } from "../../../core/scope.js";
-import { isGitUrl } from "../shared.js";
-import { INSTALLED_SOURCE_ID, marketplaceSourceId, } from "./model.js";
+import { statSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { SUBTREE_NAMES, coreCommandPaths } from '../../../build-root.js';
+import { discoverPluginCommandCandidates, validateEffectiveCommandPlugins, validatePluginCommands } from '../../../core/command-plugins/discovery.js';
+import { qualifiedTopLevelCommandName } from '../../../core/command-manifests/registry.js';
+import { listDirs, pathExists, walkFiles } from '../../../core/fs-utils.js';
+import { currentSha, gitSync } from '../../../core/git.js';
+import { listPluginMemoryDocs } from '../../../core/memory-resolver.js';
+import { memoryExtensionEffectiveCatalog, projectEffectiveMemoryExtensions } from '../../../core/memory/extensions.js';
+import { readMarketplaceManifest, readPluginManifest } from '../../../core/manifest.js';
+import { readConfig } from '../../../core/config.js';
+import { parseSubstrateDoc } from '../../../core/substrate/schema.js';
+import { projectScopeRoot, userScopeRoot } from '../../../core/scope.js';
+import { isGitUrl } from '../shared.js';
+import { INSTALLED_SOURCE_ID, marketplaceSourceId, } from './model.js';
 function parseSemver(version) {
     const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
     return match === null

package/dist/commands/pkg/browse/command-view.d.ts

@@ -1,3 +1,3 @@
-import type { CommandNode, PluginCapability } from "./model.js";
+import type { CommandNode, PluginCapability } from './model.js';
 /** Every line of one command's contract view, wrapped to `width`. */
 export declare function renderCommandView(node: CommandNode, capability: PluginCapability, width: number): string[];

package/dist/commands/pkg/browse/command-view.js

@@ -3,9 +3,9 @@
 //
 // Pure rendering. It returns styled lines already wrapped to `width`; the
 // dossier owns scrolling and never truncates what comes back.
-import { visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { theme, wrapText } from "../../../core/tui/panel.js";
-import { commandLabel } from "./model.js";
+import { visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { theme, wrapText } from '../../../core/tui/panel.js';
+import { commandLabel } from './model.js';
 /** Every line of one command's contract view, wrapped to `width`. */
 export function renderCommandView(node, capability, width) {
     const out = [];