@north-light/crouter 0.3.222 → 0.3.223

package/dist/clients/inbox/page-adapter.js

@@ -12,6 +12,7 @@ export class PageAdapter {
         this.manifest = opts.ticket.manifest;
         this.panel = mountPanel({
             manifest: opts.ticket.manifest,
+            document: opts.ticket.document,
             productKinds: opts.productKinds,
             initialResponses: opts.ticket.progress,
             cols: opts.cols,
@@ -46,7 +47,7 @@ export class PageAdapter {
     }
     reload(ticket) {
         this.manifest = ticket.manifest;
-        this.panel.loadPage(ticket.manifest, { initialResponses: ticket.progress, productKinds: this.opts.productKinds });
+        this.panel.loadPage(ticket.manifest, { document: ticket.document, initialResponses: ticket.progress, productKinds: this.opts.productKinds });
         this.opts.onDirty();
     }
     close() { this.panel.unmount(); }

package/dist/clients/inbox/tui/panel.js

@@ -1,13 +1,32 @@
+import { projectPageDisplayMarkdown } from '../../../core/human/page-markdown.js';
 import { handleKeypress } from './input.js';
 import { clampItemReviewScroll, renderFinal, renderItemReview, renderOverview } from './render.js';
 import { pageComplete, slotAnswered } from './slots.js';
-function buildInitialState(manifest, initialResponses, productKinds, editorAvailable, wrapWidth) {
+/** Same projection the inline chat block reads (page-block.ts) — the authored
+ *  prose outside slot tags. A malformed or unreadable document just yields no
+ *  display content here, same as the inline block's own reload() fallback. */
+function displayMarkdownOf(manifest, document) {
+    if (manifest.dialect !== 'jsx' || document === undefined)
+        return '';
+    try {
+        return projectPageDisplayMarkdown(document, manifest);
+    }
+    catch {
+        return '';
+    }
+}
+function buildInitialState(manifest, document, initialResponses, productKinds, editorAvailable, wrapWidth) {
     const responses = new Map();
     const validIds = new Set(manifest.slots.flatMap((slot) => slot.id === undefined ? [] : [slot.id]));
     for (const [id, response] of Object.entries(initialResponses ?? {}))
         if (validIds.has(id))
             responses.set(id, response);
-    const state = { phase: manifest.slots.length === 1 ? 'item-review' : 'overview', currentIndex: 0, manifest, slots: manifest.slots, responses, productKinds, inputMode: null, selectedAction: 0, bodyMode: 'question', scrollOffset: 0, bodyScrollOffsets: { question: 0 }, hscrollOffset: 0, hscrollMax: 0, wrapWidth, editorAvailable };
+    const displayMarkdown = displayMarkdownOf(manifest, document);
+    // Single-slot pages skip straight to item-review to save a step — but only
+    // when there is no display prose to show first; otherwise that prose would
+    // never be seen.
+    const phase = manifest.slots.length === 1 && displayMarkdown === '' ? 'item-review' : 'overview';
+    const state = { phase, currentIndex: 0, manifest, displayMarkdown, slots: manifest.slots, responses, productKinds, inputMode: null, selectedAction: 0, bodyMode: 'question', scrollOffset: 0, bodyScrollOffsets: { question: 0 }, hscrollOffset: 0, hscrollMax: 0, wrapWidth, editorAvailable };
     const first = manifest.slots.findIndex((slot) => slot.id !== undefined && !slotAnswered(state, slot));
     if (first >= 0)
         state.currentIndex = first;
@@ -16,7 +35,7 @@ function buildInitialState(manifest, initialResponses, productKinds, editorAvail
 export function collectResponses(state) { return Object.fromEntries(state.responses); }
 function rebindPersist(internals) { internals.state.persist = () => internals.callbacks.onProgress?.(collectResponses(internals.state)); }
 export function mountPanel(opts) {
-    const internals = { state: buildInitialState(opts.manifest, opts.initialResponses, opts.productKinds ?? [], opts.onEditorRequest !== undefined, opts.cols), cols: opts.cols, rows: opts.rows, mounted: true, callbacks: { onProgress: opts.onProgress, onComplete: opts.onComplete, onExit: opts.onExit, onDirty: opts.onDirty, onEditorRequest: opts.onEditorRequest } };
+    const internals = { state: buildInitialState(opts.manifest, opts.document, opts.initialResponses, opts.productKinds ?? [], opts.onEditorRequest !== undefined, opts.cols), cols: opts.cols, rows: opts.rows, mounted: true, callbacks: { onProgress: opts.onProgress, onComplete: opts.onComplete, onExit: opts.onExit, onDirty: opts.onDirty, onEditorRequest: opts.onEditorRequest } };
     rebindPersist(internals);
     const renderLines = () => {
         if (internals.state.phase === 'overview')
@@ -51,7 +70,7 @@ export function mountPanel(opts) {
                 return;
             const prior = collectResponses(internals.state);
             const merged = { ...(loadOpts?.initialResponses ?? {}), ...prior };
-            internals.state = buildInitialState(manifest, merged, loadOpts?.productKinds ?? internals.state.productKinds, internals.callbacks.onEditorRequest !== undefined, internals.cols);
+            internals.state = buildInitialState(manifest, loadOpts?.document, merged, loadOpts?.productKinds ?? internals.state.productKinds, internals.callbacks.onEditorRequest !== undefined, internals.cols);
             rebindPersist(internals);
         },
         canAcceptHostKeys: () => internals.mounted && internals.state.inputMode === null,

package/dist/clients/inbox/tui/render.js

@@ -29,10 +29,16 @@ function commentLabel(slot, anchor) {
 }
 export function renderOverview(state, cols, rows) {
     const maxW = Math.min(Math.max(20, cols - 4), 120);
+    const paneW = Math.max(20, cols - 4);
     const lines = ['', `  ${BOLD}${CYAN}${sanitize(state.manifest.title)}${RESET}`];
     if (state.manifest.subtitle)
         for (const line of wrap(sanitize(state.manifest.subtitle), maxW))
             lines.push(`  ${DIM}${line}${RESET}`);
+    if (state.displayMarkdown !== '') {
+        lines.push('');
+        for (const line of mdLines(state.displayMarkdown, maxW, paneW))
+            lines.push(`  ${line}`);
+    }
     const hasBody = state.slots.length > 0;
     if (hasBody)
         lines.push(`  ${DIM}${hline(maxW)}${RESET}`, '');

package/dist/clients/inbox/tui/types.d.ts

@@ -20,6 +20,10 @@ export interface TuiState {
     phase: Phase;
     currentIndex: number;
     manifest: PageManifest;
+    /** The authored display JSX (headings, paragraphs, prose outside slots),
+     *  projected to markdown — same projection the inline chat block uses.
+     *  Empty when the page has none, or its document was unavailable. */
+    displayMarkdown: string;
     slots: PageSlot[];
     responses: Map<string, SlotResponse>;
     productKinds: ProductPageComponents;
@@ -39,6 +43,9 @@ export interface TuiState {
 }
 export interface MountedPanelOpts {
     manifest: PageManifest;
+    /** The raw page document — needed only to project display markdown; a jsx
+     *  page without one just shows no display content, same as a read failure. */
+    document?: string;
     productKinds?: ProductPageComponents;
     initialResponses?: PageResponses | null;
     cols: number;
@@ -55,6 +62,7 @@ export interface MountedPanel {
     handleResize(cols: number, rows: number): string[];
     unmount(): void;
     loadPage(manifest: PageManifest, opts?: {
+        document?: string;
         initialResponses?: PageResponses | null;
         productKinds?: ProductPageComponents;
     }): void;

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

@@ -105,8 +105,8 @@ 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 own name directory); `command` fires when a matching shell command runs (globs vs the whole command string, `*` crossing `/`). `at` sets how much delivers: `name` the bare tag, `preview` the routing line, `content` the whole body. 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 own name directory); `command` fires when a matching shell command runs (globs vs the whole command string, `*` crossing `/`). 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 = "Gate 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_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. A bare directory name is a valid link too: following it returns that directory\u2019s listing, a browse entrance rather than a doc. 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 or label form.";
 export {};

package/dist/commands/memory/shared.js

@@ -164,7 +164,7 @@ export function coerceGate(raw) {
     return result;
 }
 // The frontmatter keys one `surfaces` entry may carry.
-const SURFACE_ENTRY_KEYS = new Set(['on', 'match', 'match-frontmatter', 'at']);
+const SURFACE_ENTRY_KEYS = new Set(['on', 'match', 'match-frontmatter', 'gate', 'at']);
 /** Coerce one `--surface` value into a validated surfaces entry. Strict where
  *  the runtime parser is tolerant: a flag that would be silently dropped or
  *  trimmed at render time is an authoring mistake and fails HERE. The entry is
@@ -173,13 +173,13 @@ const SURFACE_ENTRY_KEYS = new Set(['on', 'match', 'match-frontmatter', 'at']);
 export function coerceSurface(raw) {
     const parsed = yamlParse(raw);
     if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw usage(`--surface must be a YAML/JSON object entry {on, at, match?, match-frontmatter?}, got ${JSON.stringify(parsed)}. ` +
+        throw usage(`--surface must be a YAML/JSON object entry {on, at, match?, match-frontmatter?, gate?}, got ${JSON.stringify(parsed)}. ` +
             `Example: --surface '{on: read, match: "src/**", at: content}'`);
     }
     const rec = parsed;
     for (const key of Object.keys(rec)) {
         if (!SURFACE_ENTRY_KEYS.has(key)) {
-            throw usage(`--surface: unknown key \`${key}\` (an entry carries only on, match, match-frontmatter, at)`);
+            throw usage(`--surface: unknown key \`${key}\` (an entry carries only on, match, match-frontmatter, gate, at)`);
         }
     }
     const on = rec['on'];
@@ -223,10 +223,15 @@ export function coerceSurface(raw) {
     if ((on === 'read' || on === 'memory-read' || on === 'command') && match === undefined && matchFrontmatter === undefined) {
         throw usage(`--surface: a \`${on}\` entry requires \`match\`${on === 'read' ? ' or `match-frontmatter`' : ''}`);
     }
+    const gate = rec['gate'];
+    if (gate !== undefined && (gate === null || typeof gate !== 'object' || Array.isArray(gate))) {
+        throw usage(`--surface: invalid \`gate\`: ${JSON.stringify(gate)} (expected a field→matcher object)`);
+    }
     return {
         on,
         ...(match !== undefined ? { match } : {}),
         ...(matchFrontmatter !== undefined ? { 'match-frontmatter': matchFrontmatter } : {}),
+        ...(gate !== undefined ? { gate } : {}),
         at,
     };
 }
@@ -503,7 +508,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?}`; 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. A `./`-anchored glob is relative: for `read` to the store’s owning repo dir, for `memory-read` to the doc’s own name directory. Constraints within one entry AND together; entries OR together.' },
+    '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 the doc’s own name directory. 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.' },
 };
@@ -521,7 +526,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 own name directory); `command` fires when a matching shell command runs (globs vs the whole command string, `*` crossing `/`). `at` sets how much delivers: `name` the bare tag, `preview` the routing line, `content` the whole body. 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 own name directory); `command` fires when a matching shell command runs (globs vs the whole command string, `*` crossing `/`). 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 = 'Gate 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_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. A bare directory name is a valid link too: following it returns that directory\u2019s listing, a browse entrance rather than a doc. 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 or label form.';

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

@@ -32,6 +32,8 @@ export function renderDocView(doc, width) {
             parts.push(entry.match.join(", "));
         if (entry.matchFrontmatter !== undefined)
             parts.push(JSON.stringify(entry.matchFrontmatter));
+        if (entry.gate !== undefined)
+            parts.push(JSON.stringify(entry.gate));
         out.push(...field(entry.on, parts.join("  "), viewWidth));
     }
     if (doc.unlisted)

package/dist/core/__tests__/profile-project-memory-delivery.test.js

@@ -21,6 +21,7 @@ import { closeDb } from '../canvas/db.js';
 import { resetScopeCache } from '../scope.js';
 import { createProfile } from '../profiles/manifest.js';
 import { spawnNode } from '../runtime/nodes.js';
+import { memoryDir } from '../runtime/memory.js';
 import { clearSessionCache } from '../substrate/session-cache.js';
 import { renderKnowledgeBlock } from '../substrate/render-node.js';
 import { renderWorkspaceOpenDocs } from '../substrate/on-read-node.js';
@@ -37,6 +38,8 @@ const B = {
     nameFromPcontent: 'BODY-T9-NAMEDUP-FROM-PCONTENT',
     userDupFromPnone: 'BODY-T9-USERDUP-FROM-PNONE',
     userDupFromUser: 'BODY-T9-USERDUP-FROM-USER',
+    kindSplit: 'BODY-T9-KIND-SPLIT',
+    documentGateWins: 'BODY-T9-DOCUMENT-GATE-WINS',
 };
 let home;
 let canvasHome;
@@ -115,6 +118,30 @@ before(() => {
     // would otherwise beat.
     writeDoc(pnone, 't9-userdup-doc', autoDoc('When the user duplicate resolves', B.userDupFromPnone));
     writeDoc(user, 't9-userdup-doc', autoDoc('When the user duplicate resolves', B.userDupFromUser));
+    writeDoc(user, 't9-kind-split', [
+        '---',
+        'kind: knowledge',
+        'when-and-why-to-read: "When the node needs this kind-specific guide"',
+        'surfaces:',
+        '  - {on: boot, gate: {kind: {in: [design, spec, plan, developer]}}, at: content}',
+        '  - {on: boot, gate: {kind: {in: [general, review, advisor]}}, at: preview}',
+        '---',
+        '',
+        B.kindSplit,
+        '',
+    ].join('\n'));
+    writeDoc(user, 't9-document-gate-wins', [
+        '---',
+        'kind: knowledge',
+        'when-and-why-to-read: "When document eligibility is tested"',
+        'gate: {kind: {ne: developer}}',
+        'surfaces:',
+        '  - {on: boot, gate: {kind: developer}, at: content}',
+        '---',
+        '',
+        B.documentGateWins,
+        '',
+    ].join('\n'));
     // Hidden-count pair: a top-level dir always renders, so a dir holding only a
     // bootless doc shows as `<dir>/` + `[+1 more]` — unless its project is `none`.
     writeDoc(pnone, join('t9-none-hidden', 'probe'), bootlessDoc('When counted', 'HIDDEN-NONE'));
@@ -152,8 +179,8 @@ after(() => {
     restore('CRTR_PROFILE_ID', prevProfile);
     restore('CRTR_NODE_ID', prevNode);
 });
-function newNode() {
-    return spawnNode({ kind: 'general', cwd: cwdProject, parent: null, profile_id: profileId }).node_id;
+function newNode(kind = 'general') {
+    return spawnNode({ kind, cwd: cwdProject, parent: null, profile_id: profileId }).node_id;
 }
 test('boot delivery caps every profile project at its relationship, including the one used as cwd', () => {
     const boot = renderKnowledgeBlock(newNode(), new Map());
@@ -168,6 +195,46 @@ test('boot delivery caps every profile project at its relationship, including th
     assert.match(boot, /[├└]─ t9-pname-doc$/m, `the name-capped doc discloses as a bare name; got:\n${boot}`);
     assert.ok(!boot.includes('When the name project delivers'), 'a name-capped doc discloses no preview line');
 });
+test('surface-entry gates select the rung by node kind while the document gate remains absolute', () => {
+    for (const kind of ['design', 'spec', 'plan', 'developer']) {
+        const boot = renderKnowledgeBlock(newNode(kind), new Map());
+        assert.ok(boot.includes(B.kindSplit), `${kind} receives the content rung; got:\n${boot}`);
+    }
+    for (const kind of ['general', 'review', 'advisor']) {
+        const boot = renderKnowledgeBlock(newNode(kind), new Map());
+        assert.match(boot, /t9-kind-split {2}# read when: When the node needs this kind-specific guide\./, `${kind} receives the preview rung; got:\n${boot}`);
+        assert.ok(!boot.includes(B.kindSplit), `${kind} does not receive the body`);
+    }
+    for (const kind of ['explore', 'personal-assistant']) {
+        const boot = renderKnowledgeBlock(newNode(kind), new Map());
+        assert.ok(!boot.includes('t9-kind-split'), `${kind} receives no kind-split entry; got:\n${boot}`);
+        assert.ok(!boot.includes(B.kindSplit), `${kind} receives no kind-split body`);
+    }
+    const developer = renderKnowledgeBlock(newNode('developer'), new Map());
+    assert.ok(!developer.includes('t9-document-gate-wins'), `a failing document gate excludes every entry; got:\n${developer}`);
+    assert.ok(!developer.includes(B.documentGateWins), 'a failing document gate excludes its content');
+});
+test('a node-local doc floors to name only without boot entries', () => {
+    const node = newNode('explore');
+    writeDoc(memoryDir(node), 't9-node-local-bootless', bootlessDoc('When the node-local fallback applies', 'BODY-T9-NODE-LOCAL-BOOTLESS'));
+    writeDoc(memoryDir(node), 't9-node-local-entry-gated', [
+        '---',
+        'kind: knowledge',
+        'when-and-why-to-read: "When the node-local entry gates are tested"',
+        'surfaces:',
+        '  - {on: boot, gate: {kind: developer}, at: content}',
+        '  - {on: boot, gate: {kind: review}, at: preview}',
+        '---',
+        '',
+        'BODY-T9-NODE-LOCAL-ENTRY-GATED',
+        '',
+    ].join('\n'));
+    const boot = renderKnowledgeBlock(node, new Map());
+    assert.match(boot, /[├└]─ t9-node-local-bootless$/m, `a bootless node-local doc falls to name; got:\n${boot}`);
+    assert.ok(!boot.includes('BODY-T9-NODE-LOCAL-BOOTLESS'), 'the fallback discloses no body');
+    assert.ok(!boot.includes('t9-node-local-entry-gated'), `ineligible boot entries keep a node-local doc absent; got:\n${boot}`);
+    assert.ok(!boot.includes('BODY-T9-NODE-LOCAL-ENTRY-GATED'), 'ineligible boot entries disclose no body');
+});
 test('a `none` project contributes nothing to boot — no body, no name, no hidden count, no shadow', () => {
     const boot = renderKnowledgeBlock(newNode(), new Map());
     assert.ok(!boot.includes(B.pnone), 'a none-capped body must not render');

package/dist/core/substrate/frontmatter-validation.d.ts

@@ -1,3 +1,4 @@
+import { type SurfaceEntry } from './schema.js';
 /** Strict validation of one raw routing entry. Runtime parsing deliberately
  * tolerates malformed docs; this authoring/preflight contract does not. */
 export declare function lintSubstrateSurfaces(value: unknown): string | null;
@@ -6,8 +7,4 @@ export declare function lintSubstrateFrontmatter(fm: Record<string, unknown> | n
 /** Compatibility name for consumers that adopted lint's former export. */
 export declare const lintSubstrateSchema: typeof lintSubstrateFrontmatter;
 /** Parsed routing entries for checks that run after strict validation. */
-export declare function parsedSubstrateSurfaces(fm: Record<string, unknown>): {
-    on: string;
-    at: string;
-    match?: string[];
-}[];
+export declare function parsedSubstrateSurfaces(fm: Record<string, unknown>): SurfaceEntry[];

package/dist/core/substrate/frontmatter-validation.js

@@ -1,6 +1,6 @@
 import { isDocKind, parseSubstrateFrontmatter, SURFACE_EVENTS, SURFACE_RUNGS } from './schema.js';
 const RETIRED_FIELDS = ['system-prompt-visibility', 'file-read-visibility', 'applies-to', 'read-when'];
-const SURFACE_ENTRY_KEYS = ['on', 'match', 'match-frontmatter', 'at'];
+const SURFACE_ENTRY_KEYS = ['on', 'match', 'match-frontmatter', 'gate', 'at'];
 const SUPPRESSIBLE_RULES = ['length', 'broad-memory-read'];
 /** Strict validation of one raw routing entry. Runtime parsing deliberately
  * tolerates malformed docs; this authoring/preflight contract does not. */
@@ -8,15 +8,15 @@ export function lintSubstrateSurfaces(value) {
     if (value === undefined)
         return null;
     if (!Array.isArray(value))
-        return `invalid surfaces: ${JSON.stringify(value)} (expected a list of {on, at, match?, match-frontmatter?} entries)`;
+        return `invalid surfaces: ${JSON.stringify(value)} (expected a list of {on, at, match?, match-frontmatter?, gate?} entries)`;
     for (const raw of value) {
         if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-            return `invalid surfaces entry: ${JSON.stringify(raw)} (expected an {on, at, match?, match-frontmatter?} object)`;
+            return `invalid surfaces entry: ${JSON.stringify(raw)} (expected an {on, at, match?, match-frontmatter?, gate?} object)`;
         }
         const entry = raw;
         for (const key of Object.keys(entry)) {
             if (!SURFACE_ENTRY_KEYS.includes(key)) {
-                return `invalid surfaces entry: unknown key \`${key}\` (an entry carries only on, match, match-frontmatter, at)`;
+                return `invalid surfaces entry: unknown key \`${key}\` (an entry carries only on, match, match-frontmatter, gate, at)`;
             }
         }
         const on = entry['on'];
@@ -50,6 +50,10 @@ export function lintSubstrateSurfaces(value) {
         if ((on === 'read' || on === 'memory-read' || on === 'command') && !hasMatch && matchFrontmatter === undefined) {
             return `invalid surfaces entry: a \`${on}\` entry requires \`match\`${on === 'read' ? ' or `match-frontmatter`' : ''}`;
         }
+        const gate = entry['gate'];
+        if (gate !== undefined && (gate === null || typeof gate !== 'object' || Array.isArray(gate))) {
+            return `invalid surfaces entry \`gate\`: ${JSON.stringify(gate)} (expected a field→matcher object)`;
+        }
     }
     return null;
 }

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

@@ -1,4 +1,4 @@
-import type { SubstrateDoc } from './schema.js';
+import type { SubstrateDoc, SurfaceEntry } from './schema.js';
 import type { NodeConfigSubject } from './subject-fields.js';
 /** Does `doc` pass its gate for `subject`?
  *
@@ -11,3 +11,6 @@ import type { NodeConfigSubject } from './subject-fields.js';
  *  for this node; it remains findable by `crtr memory find` (search ignores
  *  gate + rung). */
 export declare function gatePasses(doc: SubstrateDoc, subject: NodeConfigSubject): boolean;
+/** Does a surface entry participate for `subject`? A missing subject cannot
+ * satisfy an entry gate; entries without one remain eligible. */
+export declare function surfaceEntryGatePasses(entry: Pick<SurfaceEntry, 'gate'>, subject: NodeConfigSubject | null): boolean;

package/dist/core/substrate/gate.js

@@ -19,3 +19,8 @@ export function gatePasses(doc, subject) {
         return true;
     return evalCondition(doc.gate, subject);
 }
+/** Does a surface entry participate for `subject`? A missing subject cannot
+ * satisfy an entry gate; entries without one remain eligible. */
+export function surfaceEntryGatePasses(entry, subject) {
+    return entry.gate === undefined || (subject !== null && evalCondition(entry.gate, subject));
+}

package/dist/core/substrate/on-read.js

@@ -229,7 +229,7 @@ export function renderOnReadDocsForSubject(subject, readFilePath, seen = new Map
     const readFrontmatter = readFileFrontmatter(absReadFile);
     const candidates = dedupeByPhysicalPath([...enclosingProjectDocs(absReadFile), ...resolvedDocs()])
         .filter((doc) => realpathOrSelf(doc.path) !== absReadFile)
-        .map((doc) => ({ doc, rung: readDeliveryRung(doc, absReadFile, readFrontmatter) }))
+        .map((doc) => ({ doc, rung: readDeliveryRung(doc, subject, absReadFile, readFrontmatter) }))
         .filter(({ rung }) => rung !== 'none');
     return renderCandidates(subject, candidates, seen);
 }
@@ -254,7 +254,7 @@ export function renderWorkspaceOpenDocsForSubject(subject, cwd, profileId, seen
         return '';
     }
     const candidates = dedupeByPhysicalPath(docs)
-        .map((doc) => ({ doc, rung: minRung(workspaceOpenRung(doc), doc.projectMemory) }))
+        .map((doc) => ({ doc, rung: minRung(workspaceOpenRung(doc, subject), doc.projectMemory) }))
         .filter(({ rung }) => rung !== 'none')
         .sort((a, b) => {
         const aRoot = owningRootOf(a.doc) ?? '';
@@ -272,7 +272,7 @@ export function renderWorkspaceOpenDocsForSubject(subject, cwd, profileId, seen
 export function memoryReadDocBlocks(subject, excludeRealpath, targetNames, seen) {
     const candidates = dedupeByPhysicalPath(resolvedDocs())
         .filter((doc) => realpathOrSelf(doc.path) !== excludeRealpath)
-        .map((doc) => ({ doc, rung: memoryReadDeliveryRung(doc, targetNames) }))
+        .map((doc) => ({ doc, rung: memoryReadDeliveryRung(doc, subject, targetNames) }))
         .filter(({ rung }) => rung !== 'none');
     return renderCandidateBlocks(subject, candidates, seen);
 }
@@ -282,7 +282,7 @@ export function memoryReadDocBlocks(subject, excludeRealpath, targetNames, seen)
  * dedup set as the other channels. */
 export function renderOnCommandDocsForSubject(subject, command, seen = new Map()) {
     const candidates = dedupeByPhysicalPath(resolvedDocs())
-        .map((doc) => ({ doc, rung: commandDeliveryRung(doc, command) }))
+        .map((doc) => ({ doc, rung: commandDeliveryRung(doc, subject, command) }))
         .filter(({ rung }) => rung !== 'none');
     return renderCandidates(subject, candidates, seen);
 }

package/dist/core/substrate/render.js

@@ -8,11 +8,10 @@
 // then the `preview`+`name` docs render as ONE catalog tree, each at its own
 // rung (preview → a `# read when:` routing line; name → a bare entry); a doc
 // with NO boot entry leaks only into its dir's `[+N more]` count, never a
-// name — EXCEPT a node-local doc, whose contract is "node-local rides into
-// knowledge" unconditionally: renderKnowledgeForSubject floors a bootless
-// node-local doc up to `name` so it still shows its bare name rather than
-// collapsing into a hidden count. Only gate evaluation removes a node-local
-// doc outright.
+// name — EXCEPT a node-local doc with no boot entry: renderKnowledgeForSubject
+// floors it up to `name` so it still shows its bare name rather than
+// collapsing into a hidden count. A node-local doc with boot entries remains
+// absent when none of those entries participates.
 //
 //   • the SYSTEM-PROMPT half — `<memory kind="preference">`
 //     (renderPreferencesSection) — the always-present memory-usage guidance plus
@@ -27,11 +26,11 @@
 //
 // The pipeline is explicitly TWO-STEP and must never run in the other order:
 //   1. SELECT WINNERS — MemoryDoc → parseSubstrateDoc → (null-filter
-//      non-substrate) → per-doc boot rung (`bootRung`, the max `at` over the
-//      doc's `on: boot` surfaces entries) → gatePasses → first-wins DEDUP by
+//      non-substrate) → per-doc boot rung (`bootRung`, the max `at` over
+//      participating `on: boot` surfaces entries) → gatePasses → first-wins DEDUP by
 //      name over the resolver's precedence order (nearest project > user >
 //      builtin). Node-local docs follow the same gate rule, but the
-//      knowledge-block render floors a bootless node-local doc's rung to
+//      knowledge-block render floors only a node-local doc with no boot entry to
 //      `name` — the one rung-floor exemption, scoped to the node-local store
 //      only.
 //   2. RENDER IN DISPLAY ORDER — split winners into content vs. the rest;
@@ -108,7 +107,7 @@ function selectWinners(subject, kind) {
         .filter((d) => d.kind === kind)
         .filter((d) => d.projectMemory !== 'none')
         .filter((d) => gatePasses(d, subject))
-        .map((d) => ({ ...d, bootRung: minRung(bootRung(d), d.projectMemory) }));
+        .map((d) => ({ ...d, bootRung: minRung(bootRung(d, subject), d.projectMemory) }));
     return dedupeFirstWins(eligible);
 }
 // ---------------------------------------------------------------------------
@@ -223,13 +222,9 @@ function renderGrouped(winners, rootLabel, nodeLocalSet = new Set()) {
  *  Returned across ALL kinds — node-local is the catch-all this-node store and
  *  rides into the knowledge block.
  *
- *  Node-local docs follow the same GATE rule as every other store — gate
- *  evaluation is the only thing that removes a doc here. Rung is different:
- *  node-local's contract is "node-local rides into knowledge" unconditionally,
- *  so a doc with no boot entry is retained by this function — it is the caller
- *  (renderKnowledgeForSubject) that floors a bootless node-local doc up to
- *  `name` so it still shows its bare name instead of collapsing into a
- *  `[+N more]` count. */
+ *  Node-local docs follow the same GATE rule as every other store. A doc with
+ *  no boot entry is retained here; renderKnowledgeForSubject floors it to
+ *  `name` so it shows as a bare name instead of collapsing into `[+N more]`. */
 function nodeLocalDocs(nodeId, subject) {
     const dir = memoryDir(nodeId);
     if (!pathExists(dir))
@@ -574,8 +569,8 @@ export function renderPreferencesForSubject(subject, seen) {
  *  eligible. */
 export function renderKnowledgeForSubject(subject, nodeId, seen) {
     const nodeLocal = nodeLocalDocs(nodeId, subject).map((d) => {
-        const r = bootRung(d);
-        return { ...d, bootRung: isVisible(r) ? r : 'name' };
+        const r = bootRung(d, subject);
+        return { ...d, bootRung: isVisible(r) || d.surfaces.some((e) => e.on === 'boot') ? r : 'name' };
     });
     const nodeLocalSet = new Set(nodeLocal);
     // Resolver winners first: first-wins dedup keeps the resolver's copy over a

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

@@ -1,5 +1,6 @@
 import { type ProfileProjectMemory } from '../../api/dto/profiles.js';
 import type { MemoryDoc, MemoryScope } from '../memory-resolver.js';
+import type { NodeConfigSubject } from './subject-fields.js';
 export declare const KINDS: readonly ["knowledge", "preference"];
 export type DocKind = (typeof KINDS)[number];
 /** Is `v` one of the two valid document kinds? */
@@ -34,10 +35,10 @@ export type SurfaceEvent = (typeof SURFACE_EVENTS)[number];
 export declare const SURFACE_RUNGS: readonly ["name", "preview", "content"];
 export type SurfaceRung = (typeof SURFACE_RUNGS)[number];
 /** One routing entry: when event `on` exposes a subject that fits `match`
- *  (and `matchFrontmatter`, `read` only), the doc delivers at rung `at`.
- *  Constraints within one entry AND together (each present constraint must
- *  fit; a `match` list is satisfied by any one glob); multiple entries per
- *  event OR together. */
+ *  (and `matchFrontmatter`, `read` only) and its optional node-config `gate`,
+ *  the doc delivers at rung `at`. Constraints within one entry AND together
+ *  (each present constraint must fit; a `match` list is satisfied by any one
+ *  glob); multiple entries per event OR together. */
 export interface SurfaceEntry {
     on: SurfaceEvent;
     /** Globs vs the event's subject namespace. Required on read/memory-read/
@@ -47,11 +48,15 @@ export interface SurfaceEntry {
     /** Predicate over the read file's own YAML frontmatter — `read` event only.
      *  Frontmatter key `match-frontmatter`. */
     matchFrontmatter?: GatePredicate;
+    /** Optional predicate over the current node config. Frontmatter key `gate`.
+     *  The document-level gate remains the hard eligibility check. */
+    gate?: GatePredicate;
     at: SurfaceRung;
 }
-/** A doc's boot rung: the highest `at` over its `boot` entries, `none` when
- *  it carries no boot entry. The boot render's per-doc selection input. */
-export declare function bootRung(doc: Pick<SubstrateSchema, 'surfaces'>): Rung;
+/** A doc's boot rung for `subject`: the highest `at` over participating
+ *  `boot` entries, `none` when it carries none. The boot render's per-doc
+ *  selection input. */
+export declare function bootRung(doc: Pick<SubstrateSchema, 'surfaces'>, subject: NodeConfigSubject): Rung;
 /** A gate predicate tree, evaluated by predicate.ts (`evalCondition`) against
  *  the node-config subject. Typed loosely on purpose — the matcher engine owns
  *  validation; structurally it is a field→matcher map with optional

package/dist/core/substrate/schema.js

@@ -8,6 +8,7 @@
 // never throw): invalid `surfaces` entries are dropped rather than crashing a
 // render, and `crtr memory lint` owns strict authoring-time enforcement.
 import { PROFILE_PROJECT_MEMORY_VALUES } from '../../api/dto/profiles.js';
+import { surfaceEntryGatePasses } from './gate.js';
 // ---------------------------------------------------------------------------
 // Kinds — the two semantic kinds (design §3): `knowledge` (consult — procedural
 // playbooks + factual references merged) vs `preference` (behave — standing
@@ -95,12 +96,13 @@ export const SURFACE_EVENTS = ['boot', 'workspace-open', 'read', 'memory-read',
  *  absence of an entry. (`Rung`'s `none` survives only as the internal
  *  ranking floor, e.g. `bootRung` of a doc with no boot entry.) */
 export const SURFACE_RUNGS = ['name', 'preview', 'content'];
-/** A doc's boot rung: the highest `at` over its `boot` entries, `none` when
- *  it carries no boot entry. The boot render's per-doc selection input. */
-export function bootRung(doc) {
+/** A doc's boot rung for `subject`: the highest `at` over participating
+ *  `boot` entries, `none` when it carries none. The boot render's per-doc
+ *  selection input. */
+export function bootRung(doc, subject) {
     let r = 'none';
     for (const e of doc.surfaces) {
-        if (e.on !== 'boot')
+        if (e.on !== 'boot' || !surfaceEntryGatePasses(e, subject))
             continue;
         if (rungRank(e.at) > rungRank(r))
             r = e.at;
@@ -194,8 +196,8 @@ function parseGate(v) {
  *  dropped (bad `on`, bad `at`, a read/memory-read/command entry left with
  *  neither `match` nor — read only — `match-frontmatter`). `match-frontmatter`
  *  on a non-read event is dropped from the entry, which survives iff it still
- *  carries a `match`. Lint owns strict enforcement; the runtime parser maps
- *  over many docs and must never throw. */
+ *  carries a `match`; an invalid entry `gate` is dropped. Lint owns strict
+ *  enforcement; the runtime parser maps over many docs and must never throw. */
 function parseSurfaces(v) {
     if (!Array.isArray(v))
         return [];
@@ -212,6 +214,7 @@ function parseSurfaces(v) {
             continue;
         const match = parseMatchGlobs(rec['match']);
         const matchFrontmatter = on === 'read' ? parseGate(rec['match-frontmatter']) : undefined;
+        const gate = parseGate(rec['gate']);
         if ((on === 'read' || on === 'memory-read' || on === 'command') &&
             match === undefined &&
             matchFrontmatter === undefined) {
@@ -222,6 +225,7 @@ function parseSurfaces(v) {
             at: at,
             ...(match !== undefined ? { match } : {}),
             ...(matchFrontmatter !== undefined ? { matchFrontmatter } : {}),
+            ...(gate !== undefined ? { gate } : {}),
         });
     }
     return out;