@north-light/crouter 0.3.207 → 0.3.209

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

@@ -4,13 +4,15 @@
  *  rule of its own. */
 export declare const HISTORY_DIR = ".history";
 /** File operations only — deliberately not a review lifecycle. */
-export type HistoryOp = 'create' | 'edit' | 'delete';
+export type HistoryOp = 'create' | 'edit' | 'delete' | 'move';
 export interface HistoryRecord {
     op: HistoryOp;
     at: string;
     /** Authoring node id; absent for a human at a bare CLI. */
     node?: string;
     cwd: string;
+    /** The canonical name this document answered to before a `move`; absent otherwise. */
+    from?: string;
     /** Why this revision happened. Required on `edit`, absent otherwise. */
     rationale?: string;
     /** True when the body was declared a verbatim payload from the principal. */
@@ -29,6 +31,7 @@ export declare function historyLogPathFor(memoryRoot: string, docPath: string):
  *  serialized key order — the on-disk shape consumers read. */
 export declare function buildHistoryRecord(input: {
     op: HistoryOp;
+    from?: string;
     rationale?: string;
     verbatim?: boolean;
     before: string;

package/dist/core/memory/history.js

@@ -40,6 +40,7 @@ export function buildHistoryRecord(input) {
         at: new Date().toISOString(),
         ...(env['CRTR_NODE_ID'] ? { node: env['CRTR_NODE_ID'] } : {}),
         cwd: env['CRTR_NODE_CWD'] ?? process.cwd(),
+        ...(input.from !== undefined ? { from: input.from } : {}),
         ...(input.rationale !== undefined ? { rationale: input.rationale } : {}),
         ...(input.verbatim === true ? { verbatim: true } : {}),
         before: input.before,

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

@@ -2,10 +2,11 @@ import type { RefMeta } from '../runtime/broker-protocol.js';
 /**
  * Build the inline memory-reference inventory: every referenceable document
  * in this node's corpus, precedence-deduped first-wins by canonical name,
- * both kinds, no gate/rung/`slash` filtering, INDEX docs folded to their bare
- * directory name. Returns display metadata (`refs`, stably sorted by winning
- * scope then name) plus the resolution set (`names`) that both the broker's
- * per-submission resolver and `buildGuidance` test tokens against.
+ * both kinds, no gate/rung/`slash` filtering. Returns display metadata
+ * (`refs`, stably sorted by winning scope then name) plus the resolution set
+ * (`names` — doc names plus every proper directory prefix, because a bare-dir
+ * ref is a legal listing link) that both the broker's per-submission resolver
+ * and `buildGuidance` test tokens against.
  */
 export declare function buildRefInventory(): {
     refs: RefMeta[];

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

@@ -18,8 +18,10 @@
 //     automatic boot/on-read surfacing only (spec §7.1), and `slash` governs
 //     command registration only (spec §4.3). An explicit human reference
 //     outranks both.
-//   • A directory's INDEX doc folds to its bare directory name (`taste`, not
-//     `taste/INDEX`), matching what `crtr memory read taste` accepts.
+//   • Directory names are referenceable too: a bare-dir `[[ref]]` opens the
+//     directory's listing through `crtr memory read <dir>`, so every proper
+//     name-prefix of a winning doc joins the resolution set — resolution
+//     only, never a display row.
 //   • A malformed doc (no valid `kind`) is already dropped by
 //     `parseSubstrateDoc` returning null, so it never reaches the winners map.
 //
@@ -29,7 +31,6 @@
 // cache it reads through.
 import { listAllMemoryDocs } from '../memory-resolver.js';
 import { parseSubstrateDoc } from '../substrate/schema.js';
-import { displayName } from '../substrate/ceiling.js';
 import { cachedSubstrateDocsInclusive } from '../substrate/session-cache.js';
 // Display-sort weight matching resolution precedence (node > project >
 // profile > user > builtin) — display-only; resolution itself is
@@ -44,26 +45,21 @@ const SCOPE_SORT_RANK = {
 /**
  * Build the inline memory-reference inventory: every referenceable document
  * in this node's corpus, precedence-deduped first-wins by canonical name,
- * both kinds, no gate/rung/`slash` filtering, INDEX docs folded to their bare
- * directory name. Returns display metadata (`refs`, stably sorted by winning
- * scope then name) plus the resolution set (`names`) that both the broker's
- * per-submission resolver and `buildGuidance` test tokens against.
+ * both kinds, no gate/rung/`slash` filtering. Returns display metadata
+ * (`refs`, stably sorted by winning scope then name) plus the resolution set
+ * (`names` — doc names plus every proper directory prefix, because a bare-dir
+ * ref is a legal listing link) that both the broker's per-submission resolver
+ * and `buildGuidance` test tokens against.
  */
 export function buildRefInventory() {
     const docs = cachedSubstrateDocsInclusive(listAllMemoryDocs, parseSubstrateDoc);
-    // First-wins by canonical (INDEX-folded) name: docs arrive already in
-    // precedence order (listAllMemoryDocs' nearest-first source ordering), so
-    // the first doc seen for a name is the winner.
+    // First-wins by canonical name: docs arrive already in precedence order
+    // (listAllMemoryDocs' nearest-first source ordering), so the first doc seen
+    // for a name is the winner.
     const winners = new Map();
     for (const doc of docs) {
-        const name = displayName(doc.name);
-        // A root INDEX folds to '' (no bare-directory token exists for it) and
-        // has no other nonempty canonical identity in this corpus, so it has
-        // no inline token to offer — omit it rather than expose `name: ''`.
-        if (name === '')
-            continue;
-        if (!winners.has(name))
-            winners.set(name, doc);
+        if (!winners.has(doc.name))
+            winners.set(doc.name, doc);
     }
     const refs = [];
     for (const [name, doc] of winners) {
@@ -75,5 +71,13 @@ export function buildRefInventory() {
             return scopeDelta;
         return a.name.localeCompare(b.name);
     });
-    return { refs, names: new Set(refs.map((r) => r.name)) };
+    const names = new Set(refs.map((r) => r.name));
+    // Directory names resolve as listing links, so they join the set — but not
+    // the display rows: a dir has no kind/short-form to show.
+    for (const name of winners.keys()) {
+        const segs = name.split('/');
+        for (let i = 1; i < segs.length; i++)
+            names.add(segs.slice(0, i).join('/'));
+    }
+    return { refs, names };
 }

package/dist/core/memory-resolver.d.ts

@@ -5,8 +5,8 @@ import { type InstalledPlugin, type Scope } from '../types.js';
  * stack nearest > ... > profile > user > builtin) for strong matches: (1) exact
  * substrate identity (`doc.name === query` — the explicit frontmatter `name`,
  * or its path-derived fallback), then (2) direct `memory/<name>.md` physical
- * path (plus the bare-dir/bare-plugin-name → `INDEX.md` convenience neither
- * identity nor a literal path expresses). Only when no source has a strong
+ * path. A directory name resolves to NO doc — the read leaf answers it with
+ * the directory's listing. Only when no source has a strong
  * match does a second nearest-first pass try bare leaf-name fallback (final
  * path segment only). Thus scope precedence resolves competing strong matches,
  * while a nearer nested doc's coincidental leaf can never shadow a farther
@@ -123,8 +123,8 @@ export declare function listAllMemoryDocs(scope?: MemoryScope, quiet?: boolean,
  *  tree segment for segment with `.jsonl` in place of `.md`. Reuses the doc
  *  resolution rules so a log outlives its doc under the same name the doc had:
  *  numeric prefixes stay prefix-blind (`00-topic.md` logged at
- *  `.history/00-topic.jsonl` still answers to `topic`) and a bare directory
- *  name falls back to its INDEX log. Returns null when nothing resolves. */
+ *  `.history/00-topic.jsonl` still answers to `topic`). Returns null when
+ *  nothing resolves. */
 export declare function resolveHistoryLogPath(historyDir: string, segments: string[]): string | null;
 export interface MemoryDocSnapshot {
     /** Every document in default scope precedence order, loaded once. */

package/dist/core/memory-resolver.js

@@ -305,8 +305,7 @@ function matchNormalizedChild(dir, segment, want, ext = '.md') {
 /** Resolve a NORMALIZED (numeric-prefix-stripped) segment path against a
  *  physical memory dir: walk intermediate segments matching each as a
  *  directory by normalized name, then resolve the final segment as either a
- *  `.md` file or a directory (the bare-dir -> INDEX.md fallback needs the dir
- *  match even when a same-named file also exists). Either half is null when
+ *  `.md` file or a directory. Either half is null when
  *  the segment path does not resolve that way. This is what makes
  *  `00-runtime-base.md` findable as `runtime-base` and `01-spine/00-has-manager`
  *  findable as `spine/has-manager` — the physical path keeps its pins, only
@@ -329,28 +328,16 @@ function resolveNormalizedPath(baseDir, segments, ext = '.md') {
  *  tree segment for segment with `.jsonl` in place of `.md`. Reuses the doc
  *  resolution rules so a log outlives its doc under the same name the doc had:
  *  numeric prefixes stay prefix-blind (`00-topic.md` logged at
- *  `.history/00-topic.jsonl` still answers to `topic`) and a bare directory
- *  name falls back to its INDEX log. Returns null when nothing resolves. */
+ *  `.history/00-topic.jsonl` still answers to `topic`). Returns null when
+ *  nothing resolves. */
 export function resolveHistoryLogPath(historyDir, segments) {
-    const { filePath, dirPath } = resolveNormalizedPath(historyDir, segments, '.jsonl');
-    if (filePath)
-        return filePath;
-    if (dirPath) {
-        const index = matchNormalizedChild(dirPath, 'INDEX', 'file', '.jsonl');
-        if (index)
-            return index;
-    }
-    return null;
+    return resolveNormalizedPath(historyDir, segments, '.jsonl').filePath;
 }
 /** Direct full-path lookup of memory/<name>.md within ONE source. Returns that
  *  source's single hit, or undefined — a source can produce at most one direct
  *  match (native wins over plugin within the source, and at most one plugin's
- *  name can match).
- *
- *  A directory INDEX is the cleaner contract: when `<name>.md` is absent but
- *  `<name>/INDEX.md` exists, the bare dir name (`taste`) resolves to the dir's
- *  INDEX doc — carrying the dir name as its identity. (`taste/INDEX` still
- *  resolves directly as the file path.)
+ *  name can match). A directory name matches NO doc here: the read leaf
+ *  answers a directory with its listing, never a stand-in document.
  *
  *  `name`'s segments are already normalized (a caller-supplied identifier is
  *  never authored with a numeric prefix); resolution against the physical tree
@@ -362,40 +349,26 @@ function findMemoryMatchInSource(name, segments, source) {
     // precedence), then its enabled plugins.
     const dir = source.memoryDir;
     if (dir) {
-        const { filePath, dirPath } = resolveNormalizedPath(dir, segments);
+        const { filePath } = resolveNormalizedPath(dir, segments);
         if (!isLegacySkillDoc && filePath !== null)
             return loadMemoryDoc(source.scope, dir, filePath, name);
-        if (dirPath !== null) {
-            const indexPath = join(dirPath, 'INDEX.md');
-            if (pathExists(indexPath))
-                return loadMemoryDoc(source.scope, dir, indexPath, name);
-        }
     }
     // Plugin memory dir: a `<plugin>/<rest>` name resolves against that enabled
     // plugin's memory/ tree (the `<pluginName>/` mount that listAllMemoryDocs
-    // enumerates — `read` must resolve what `list` shows). A BARE plugin name
-    // (no slash) resolves the plugin-root INDEX.md, mirroring the native
-    // bare-dir-name -> INDEX.md contract for the plugin mount root.
+    // enumerates — `read` must resolve what `list` shows).
     const slash = name.indexOf('/');
-    const pluginName = slash > 0 ? name.slice(0, slash) : name;
-    const rest = slash > 0 ? name.slice(slash + 1) : '';
+    if (slash <= 0)
+        return undefined;
+    const pluginName = name.slice(0, slash);
+    const rest = name.slice(slash + 1);
     for (const p of source.plugins) {
         if (p.name !== pluginName)
             continue;
         const pdir = pluginMemoryDir(p);
-        const restSegments = rest ? rest.split('/') : [];
-        if (rest) {
-            const { filePath } = resolveNormalizedPath(pdir, restSegments);
-            if (restSegments.at(-1) !== 'SKILL' && filePath !== null)
-                return loadMemoryDoc(source.scope, pdir, filePath, name);
-        }
-        // Bare name -> <plugin>/memory/INDEX.md; slashed name -> dir INDEX.
-        const pIndexDir = rest ? resolveNormalizedPath(pdir, restSegments).dirPath : pdir;
-        if (pIndexDir !== null) {
-            const pindex = join(pIndexDir, 'INDEX.md');
-            if (pathExists(pindex))
-                return loadMemoryDoc(source.scope, pdir, pindex, name);
-        }
+        const restSegments = rest.split('/');
+        const { filePath } = resolveNormalizedPath(pdir, restSegments);
+        if (restSegments.at(-1) !== 'SKILL' && filePath !== null)
+            return loadMemoryDoc(source.scope, pdir, filePath, name);
     }
     return undefined;
 }

package/dist/core/runtime/bearings.d.ts

@@ -1,4 +1,5 @@
 import { type Cron } from '../canvas/index.js';
+import type { InjectedDocs } from '../substrate/injected-store.js';
 /** The bearings custom type is shared with every attached renderer. */
 export { CONTEXT_INTRO_CUSTOM_TYPE } from '../../shared/generated-context.js';
 /** The `<project_context>` block — the `<environment>` snapshot only: a
@@ -71,10 +72,10 @@ export declare function buildWakeBearings(origin: WakeOrigin): string;
  *      from.
  *   2. `<memory kind="knowledge">` — the consultable boot catalog, a SIBLING of
  *      the bearings (never nested under the context dir). Dropped when empty.
- *   3. `<auto-loaded-context>` — memories whose `applies-to: "."` fires because
- *      cwd/profile mounted their owning project store. Dropped when empty.
+ *   3. `<auto-loaded-context>` — memories whose `on: workspace-open` entry fires
+ *      because cwd/profile mounted their owning project store. Dropped when empty.
  *   4. `<project_context>` — the cwd/git environment snapshot. pi's own
  *      AGENTS.md/CLAUDE.md injection stays suppressed (`noContextFiles` in
  *      broker.ts); `crtr sys sync project-guidance` imports that guidance into
  *      the directory's `.crouter/memory/INDEX.md` front door. */
-export declare function buildContextBearings(nodeId: string, seen?: Set<string>): string;
+export declare function buildContextBearings(nodeId: string, seen?: InjectedDocs): string;

package/dist/core/runtime/bearings.js

@@ -340,8 +340,8 @@ function managedWorktreeNote(node) {
  *      from.
  *   2. `<memory kind="knowledge">` — the consultable boot catalog, a SIBLING of
  *      the bearings (never nested under the context dir). Dropped when empty.
- *   3. `<auto-loaded-context>` — memories whose `applies-to: "."` fires because
- *      cwd/profile mounted their owning project store. Dropped when empty.
+ *   3. `<auto-loaded-context>` — memories whose `on: workspace-open` entry fires
+ *      because cwd/profile mounted their owning project store. Dropped when empty.
  *   4. `<project_context>` — the cwd/git environment snapshot. pi's own
  *      AGENTS.md/CLAUDE.md injection stays suppressed (`noContextFiles` in
  *      broker.ts); `crtr sys sync project-guidance` imports that guidance into
@@ -365,8 +365,8 @@ export function buildContextBearings(nodeId, seen) {
         bearings.push('', orchestratorContextNote(nodeId));
     bearings.push('</crtr-bearings>');
     // The consultable catalog rides BESIDE the bearings, not inside them.
-    const knowledge = renderKnowledgeBlock(nodeId);
-    // A workspace mount is the initial read of its root (`applies-to: "."`).
+    const knowledge = renderKnowledgeBlock(nodeId, seen);
+    // A workspace mount is the initial read of its root (`on: workspace-open`).
     const workspaceContext = renderWorkspaceOpenDocs(nodeId, seen);
     // Hidden applet/situation-origin ambient context (see situational-context.ts)
     // — the stored `situational` card, placed in the bearings BODY, so it is a

package/dist/core/runtime/broker/fault-retry.js

@@ -208,12 +208,7 @@ export class FaultRetry {
                 return;
             if (unconfigured)
                 clearFault(this.deps.nodeId, { link: 'pi→provider' });
-            await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {
-                reason: 'model-fallback',
-                from: currentSpec,
-                to: resolved,
-                cause: unconfigured ? 'credential' : 'not-found',
-            }, formatModelFallbackRecovery(currentSpec, resolved, unconfigured ? 'credential' : 'not-found'))));
+            await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, formatModelFallbackRecovery(currentSpec, resolved, unconfigured ? 'credential' : 'not-found'))));
         })().catch((err) => {
             emitEvent({ level: 'debug', event: 'broker.runtime.diagnostic', fields: { message: `${unconfigured ? 'unconfigured-provider' : 'not_found'} fallback failed: ${err instanceof Error ? err.message : String(err)}` } });
         }).finally(() => {
@@ -300,6 +295,6 @@ export class FaultRetry {
         if (this.deps.installedGeneration() !== generation || this.deps.currentSession() !== candidateSession)
             return;
         recordFault(this.deps.nodeId, plan.fault);
-        await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', { reason: fault.kind === 'connection' ? 'connection' : 'provider' }, fault.kind === 'connection' ? CONNECTION_FAULT_RECOVERY_BODY : PROVIDER_FAULT_RECOVERY_BODY)));
+        await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, fault.kind === 'connection' ? CONNECTION_FAULT_RECOVERY_BODY : PROVIDER_FAULT_RECOVERY_BODY)));
     }
 }

package/dist/core/runtime/broker/frame-dispatch.js

@@ -1442,7 +1442,7 @@ export function createFrameDispatchContext(deps) {
                             fresh.since !== authFault.since)
                             return;
                         clearFault(nodeId, { link: 'pi→provider' });
-                        await authFaultSession.prompt(formatCard('recovery', { reason: 'auth' }, AUTH_FAULT_RECOVERY_BODY));
+                        await authFaultSession.prompt(formatCard('recovery', {}, AUTH_FAULT_RECOVERY_BODY));
                     }
                     catch (err) {
                         emitEvent({

package/dist/core/runtime/broker/tool-groups.js

@@ -4,7 +4,7 @@ import { jobDir } from '../../canvas/paths.js';
 import { readConfig } from '../../config.js';
 import { emitEvent } from '../../events/emit.js';
 import { atomicWriteJson, readJsonIfExists } from '../../fs-utils.js';
-import { assistantVisibleText, isTrueUserMessage, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
+import { assistantVisibleText, isGroupBoundaryKind, isTrueUserMessage, normalizeToolGroupSummaryRecord, } from '../../../shared/tool-groups.js';
 import { generatedContextText, parseCard } from '../../../shared/generated-context.js';
 import { headlessToolGroupSummary, serializeToolGroup } from '../tool-group-summary.js';
 const PENDING_TOOL_SUMMARY_KEY_MAX_CHARS = 1_000;
@@ -140,11 +140,12 @@ export class ToolGroupTracker {
         if (item.display === false)
             return;
         const text = generatedContextText(item);
-        const kind = parseCard(item)?.kind;
-        const isBearingsOrRevive = kind === 'bearings' || kind === 'revive';
-        if (isBearingsOrRevive) {
-            if (this.openToolGroup !== undefined && text !== '')
-                this.openToolGroup.pieces.push({ type: 'text', text });
+        const card = parseCard(item);
+        // A boundary card ends the preceding run and becomes the next group's
+        // context, exactly as a person's message does; the viewer reads the same
+        // set, so both sides fold at the same seams.
+        if (card !== null && isGroupBoundaryKind(card.kind)) {
+            this.visibleBoundary(text);
             return;
         }
         const group = this.ensureOpenToolGroup();

package/dist/core/runtime/broker-extension-render.d.ts

@@ -1,3 +1,4 @@
+import type { InjectedDocs } from '../substrate/injected-store.js';
 import type { BrokerExtensionNodeDTO, BrokerExtensionStateDTO } from '../../api/dto/broker-ops.js';
 export declare function editorLabelForBrokerNode(node: BrokerExtensionNodeDTO): string;
 /** Same environment-only project context rendered at normal boot, without a
@@ -6,9 +7,9 @@ export declare function buildProjectContextBlockForBroker(cwd: string): string;
 /** `situational` is the node's stored situational card, placed in the bearings
  *  BODY — the one place in the system where a runtime card nests inside
  *  another (see situational-context.ts). '' when none is set. */
-export declare function buildContextBearingsFromState(state: BrokerExtensionStateDTO, projectContext: string, situational?: string, seen?: Set<string>): string;
+export declare function buildContextBearingsFromState(state: BrokerExtensionStateDTO, projectContext: string, situational?: string, seen?: InjectedDocs): string;
 export declare function buildForkBearingsFromState(state: BrokerExtensionStateDTO, situational?: string): string;
-export declare function renderPreferencesFromState(state: BrokerExtensionStateDTO): string;
+export declare function renderPreferencesFromState(state: BrokerExtensionStateDTO, seen?: InjectedDocs): string;
 /** A canonical report ref has already been validated by crtrd in state. The
  * broker reads only its local filesystem content; no canvas accessor is needed. */
 export declare function reportPathFromRef(ref: string, reportNodes: ReadonlyMap<string, unknown>): string | null;

package/dist/core/runtime/broker-extension-render.js

@@ -158,7 +158,7 @@ export function buildContextBearingsFromState(state, projectContext, situational
     if (node.mode === 'orchestrator')
         bearings.push('', `Because you persist across refresh cycles, your context directory (${contextDir(node.node_id)}) is also where a future cycle of you resumes the work — keep the working notes and decisions a refreshed you would need there, alongside the docs you share with the nodes you spawn.`);
     bearings.push('</crtr-bearings>');
-    const knowledge = renderKnowledgeForSubject(state.subject, node.node_id);
+    const knowledge = renderKnowledgeForSubject(state.subject, node.node_id, seen);
     const workspace = renderWorkspaceOpenDocsForSubject(state.subject, node.cwd, node.profile_id, seen);
     return [bearings.join('\n'), knowledge, workspace, situational, projectContext].filter((part) => part !== '').join('\n');
 }
@@ -186,8 +186,8 @@ export function buildForkBearingsFromState(state, situational = '') {
     bearings.push('', 'The first real user message after these bearings is your mandate.', '</crtr-bearings>');
     return [bearings.join('\n'), situational].filter((part) => part !== '').join('\n');
 }
-export function renderPreferencesFromState(state) {
-    return interpolateNodePaths(renderPreferencesForSubject(state.subject).block, state.node.node_id);
+export function renderPreferencesFromState(state, seen) {
+    return interpolateNodePaths(renderPreferencesForSubject(state.subject, seen).block, state.node.node_id);
 }
 /** A canonical report ref has already been validated by crtrd in state. The
  * broker reads only its local filesystem content; no canvas accessor is needed. */

package/dist/core/runtime/broker.js

@@ -359,13 +359,13 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
         const liveSession = rebind.session();
         const identified = snapshotMessages(liveSession, boundaryReviewId);
         const tail = normalizeSnapshotTail(client.snapshotTail);
+        // A tail is only usable with stable ids, which let its recipient page back
+        // to the omitted history.
         const retained = identified === undefined || tail === undefined ? identified : identified.slice(-tail);
         const messages = retained?.map(({ message }) => message)
-            ?? (tail === undefined
-                ? liveSession.sessionManager.buildSessionContext().messages
-                : liveSession.sessionManager.buildSessionContext().messages.slice(-tail));
+            ?? liveSession.sessionManager.buildSessionContext().messages;
         const fullToolGroupSummaries = toolGroups.summaries();
-        const retainedToolCallIds = tail === undefined ? undefined : toolCallIds(messages);
+        const retainedToolCallIds = retained !== undefined && tail !== undefined ? toolCallIds(messages) : undefined;
         const toolGroupSummaries = retainedToolCallIds === undefined
             ? fullToolGroupSummaries
             : Object.fromEntries(Object.entries(fullToolGroupSummaries).filter(([id]) => retainedToolCallIds.has(id)));

package/dist/core/runtime/kickoff.js

@@ -318,14 +318,8 @@ export function buildReviveKickoff(meta, bearings, wakeReason) {
     if (bearings.driftGuidance !== null) {
         parts.push(`<persona-transition>\nYour role was changed while you were away. ${bearings.driftGuidance}\n</persona-transition>`);
     }
-    // The whole kickoff is one runtime card. Its facts are what this producer
-    // knows about the revive, and they are the ONLY thing a reader may classify or
-    // summarize on — the prose above stays free to be reworded. The envelope is
-    // also what keeps a fresh revive out of canvas-goal-capture's first-real-input
-    // path, which would otherwise overwrite a bare root's mandate and rename it.
-    return formatCard('revive', {
-        mode: meta.mode,
-        ...(meta.cycle_pending === true ? { cycle: true } : {}),
-        ...(wakeReason === undefined ? {} : { wake: wakeReason.kind }),
-    }, `\n${parts.join('\n\n')}\n`);
+    // The envelope keeps a fresh revive out of canvas-goal-capture's
+    // first-real-input path, which would otherwise overwrite a bare root's
+    // mandate and rename it.
+    return formatCard('revive', {}, `\n${parts.join('\n\n')}\n`);
 }

package/dist/core/runtime/memory.js

@@ -1,9 +1,8 @@
 // memory.ts — the node-local substrate document store.
 //
 // One scope lives here: node-local memory, a `memory/` directory of substrate
-// documents (.md files with typed frontmatter — kind, when, why,
-// system-prompt-visibility, gate) inside a node's context dir; it dies with the
-// node. User-global and project memory are scope-resolved stores — see
+// documents (.md files with typed frontmatter — kind, when-and-why-to-read,
+// surfaces, gate) inside a node's context dir; it dies with the node. User-global and project memory are scope-resolved stores — see
 // `scopeMemoryDir` in core/scope.ts.
 import { join } from 'node:path';
 // Import the pure path helper from paths.ts directly, NOT the canvas/index.js

package/dist/core/runtime/node-read.js

@@ -263,7 +263,13 @@ export async function readNodeMessagesPage(nodeId, { cursor, limit = 200 }) {
     }
     const { messages, identified } = await reconstructVisibleMessages(nodeId);
     const before = cursor === undefined ? messages.length : decodeMessagesCursor(cursor, messages.length);
-    const start = Math.max(0, before - limit);
+    let start = Math.max(0, before - limit);
+    while (start > 0
+        && typeof messages[start] === 'object'
+        && messages[start] !== null
+        && messages[start].role === 'toolResult') {
+        start--;
+    }
     const page = identified?.slice(start, before);
     return {
         messages: page?.map(({ message }) => message) ?? messages.slice(start, before),

package/dist/core/runtime/stop-guard.js

@@ -28,11 +28,11 @@ import { readOutputRequest } from './structured-output.js';
 export { STALL_REPROMPT } from '../../shared/generated-context.js';
 /** Format the stop guard's reprompt for a valid structured-output request. */
 function formatValidStructuredOutputReprompt(schema) {
-    return formatCard('stop-guard', { reason: 'structured-output' }, formatStructuredOutputReprompt(JSON.stringify(schema, null, 2)));
+    return formatCard('stop-guard', {}, formatStructuredOutputReprompt(JSON.stringify(schema, null, 2)));
 }
 /** Format the stop guard's reprompt for an invalid structured-output request file. */
 function formatInvalidStructuredOutputReprompt(error) {
-    return formatCard('stop-guard', { reason: 'structured-output' }, `Structured-output request file is invalid and cannot be used: ${error}\n\n` +
+    return formatCard('stop-guard', {}, `Structured-output request file is invalid and cannot be used: ${error}\n\n` +
         `You have two options:\n` +
         `1. Remove the invalid file (the output-schema.json in your node directory has been corrupted)\n` +
         `2. Fix the corruption if you know the original request schema\n\n` +
@@ -99,6 +99,6 @@ export function evaluateStop(nodeId, signals, backgroundJobsRunning = activeBack
     return {
         action: 'reprompt',
         reason: 'stalled',
-        message: formatCard('stop-guard', { reason: 'stalled' }, STALL_REPROMPT),
+        message: formatCard('stop-guard', {}, STALL_REPROMPT),
     };
 }

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

@@ -1,11 +1,14 @@
-export { KINDS, isDocKind, RUNGS, rungRank, rungAtLeast, FALLBACK_RUNG, parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, normalizeNameSegment, normalizeDocName, resolveDocName, } from './schema.js';
-export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc } from './schema.js';
+export { KINDS, isDocKind, RUNGS, rungRank, rungAtLeast, SURFACE_EVENTS, SURFACE_RUNGS, bootRung, parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, normalizeNameSegment, normalizeDocName, resolveDocName, } from './schema.js';
+export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc, SurfaceEntry, SurfaceEvent, SurfaceRung } from './schema.js';
+export { matchesReadEntry, matchesMemoryReadEntry, matchesCommandEntry, readDeliveryRung, workspaceOpenRung, memoryReadDeliveryRung, commandDeliveryRung, owningRootOf, underOwningRoot } from './surface-match.js';
+export { dirDedupKey, docsByName, isDirName, ancestorDirsOf, renderDirListing } from './listings.js';
+export { deliveredAtOrAbove, recordDelivery, mergeInjectedDocs } from './injected-store.js';
+export type { InjectedDocs } from './injected-store.js';
 export { scopeForCwd, profileNameFor } from './subject-fields.js';
 export type { NodeConfigSubject } from './subject-fields.js';
 export { spineDepth, assembleNodeSubject } from './subject.js';
 export { gatePasses } from './gate.js';
-export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveSystemPromptRung, } from './ceiling.js';
 export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject } from './on-read.js';
+export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject, renderOnCommandDocsForSubject, renderCandidateBlocks, memoryReadDocBlocks } from './on-read.js';
 export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read-node.js';

package/dist/core/substrate/index.js

@@ -8,19 +8,21 @@ export {
 KINDS, isDocKind, 
 // ladder
 RUNGS, rungRank, rungAtLeast, 
-// fallback floor
-FALLBACK_RUNG, 
+// surfaces (event routing)
+SURFACE_EVENTS, SURFACE_RUNGS, bootRung, 
 // parse + render-shared helpers
 parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, 
 // display-name normalization
 normalizeNameSegment, normalizeDocName, 
 // substrate identity (explicit-name-then-path-fallback)
 resolveDocName, } from './schema.js';
+export { matchesReadEntry, matchesMemoryReadEntry, matchesCommandEntry, readDeliveryRung, workspaceOpenRung, memoryReadDeliveryRung, commandDeliveryRung, owningRootOf, underOwningRoot } from './surface-match.js';
+export { dirDedupKey, docsByName, isDirName, ancestorDirsOf, renderDirListing } from './listings.js';
+export { deliveredAtOrAbove, recordDelivery, mergeInjectedDocs } from './injected-store.js';
 export { scopeForCwd, profileNameFor } from './subject-fields.js';
 export { spineDepth, assembleNodeSubject } from './subject.js';
 export { gatePasses } from './gate.js';
-export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveSystemPromptRung, } from './ceiling.js';
 export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject } from './on-read.js';
+export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject, renderOnCommandDocsForSubject, renderCandidateBlocks, memoryReadDocBlocks } from './on-read.js';
 export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read-node.js';

package/dist/core/substrate/injected-store.d.ts

@@ -1,16 +1,28 @@
-/** The process-shared dedup set for a node: loaded from disk once, then the
- *  SAME Set instance on every call, so all hooks in this pi process grow and
- *  consult one set. Daemon-side deliveries (a warm-spare claim) write the disk
+import { type Rung } from './schema.js';
+/** realpath → highest rung rank delivered this transcript (1=name, 2=preview,
+ *  3=content — `rungRank` of the delivered rung). */
+export type InjectedDocs = Map<string, number>;
+/** Already delivered at `rung` or above? — the skip test every channel runs
+ *  before rendering a doc (or a listing line, at preview) again. */
+export declare function deliveredAtOrAbove(seen: InjectedDocs, realpath: string, rung: Rung): boolean;
+/** Record a delivery at `rung`, keeping the highest rank seen. */
+export declare function recordDelivery(seen: InjectedDocs, realpath: string, rung: Rung): void;
+/** Max-merge `source` into `target` — used to fold an out-of-process delivery
+ *  (the daemon's warm-spare bearings push) into a live process's shared map. */
+export declare function mergeInjectedDocs(target: InjectedDocs, source: InjectedDocs): void;
+/** The process-shared dedup map for a node: loaded from disk once, then the
+ *  SAME Map instance on every call, so all hooks in this pi process grow and
+ *  consult one map. Daemon-side deliveries (a warm-spare claim) write the disk
  *  file from another process; consumers that must see those merge the plain
  *  `loadInjectedDocs` result in before rendering. */
-export declare function sharedInjectedDocs(nodeId: string): Set<string>;
-/** Rehydrate a node's on-read dedup set from disk. Returns an empty set when the
- *  file is absent, unreadable, or malformed (a fresh transcript, or a node that
- *  has not yet surfaced any on-read doc). */
-export declare function loadInjectedDocs(nodeId: string): Set<string>;
-/** Persist a node's on-read dedup set. Called after each read that surfaced a
- *  new doc, so the grown set survives a later dormancy. */
-export declare function saveInjectedDocs(nodeId: string, seen: Set<string>): void;
-/** Drop a node's persisted dedup set. Called by the launch paths that start a
+export declare function sharedInjectedDocs(nodeId: string): InjectedDocs;
+/** Rehydrate a node's dedup map from disk. Returns an empty map when the file
+ *  is absent, unreadable, or malformed (a fresh transcript, or a node that has
+ *  not yet surfaced any doc). */
+export declare function loadInjectedDocs(nodeId: string): InjectedDocs;
+/** Persist a node's dedup map. Called after each delivery that grew it, so
+ *  the grown map survives a later dormancy. */
+export declare function saveInjectedDocs(nodeId: string, seen: InjectedDocs): void;
+/** Drop a node's persisted dedup map. Called by the launch paths that start a
  *  FRESH transcript, so the new conversation surfaces docs from scratch. */
 export declare function clearInjectedDocs(nodeId: string): void;