@north-light/crouter 0.3.227 → 0.3.229

package/dist/core/runtime/promote.js

@@ -1,23 +1,10 @@
-// Promotion — the worker→orchestrator polymorph (mode→orchestrator).
+// Promotion changes mode, optionally kind/lifecycle, rebuilds the durable launch
+// spec, and seeds a roadmap. In the current context, the broker's provider gate
+// appends pending transition context before the next response. A fresh context
+// instead boots from current system and bearings snapshots.
 //
-// Two stages:
-//   1. Promotion → mode flips to orchestrator (mid-turn). This call flips the
-//      node's mode and (optionally) its KIND, REWRITES its launch spec to that
-//      kind's orchestrator persona (so the next revive comes back as that
-//      orchestrator), and seeds a roadmap scaffold.
-//      The transition guidance the node needs is injected CENTRALLY by the
-//      persona injector (runtime/persona.ts) at the turn boundary — promote()
-//      itself returns no guidance and emits none by hand.
-//   2. Refresh → persona swap (permanent). On the next fresh revive the node
-//      starts with the orchestrator system prompt baked in (because the launch
-//      spec now says orchestrator). The injected guidance bridges until then.
-//
-// Mode and lifecycle are ORTHOGONAL: promotion flips mode only. Lifecycle stays
-// whatever it was (a promoted child is terminal/orchestrator — still reports up
-// + reaps) unless the caller passes `resident:true` to also make it resident.
-//
-// Trigger is persistence-need (deliberate, or a refresh-yield with open work),
-// never the mere act of spawning a child.
+// Mode and lifecycle remain orthogonal: promotion changes lifecycle only when
+// the caller explicitly requests residency.
 import { getNode, updateNode } from '../canvas/index.js';
 import { transition } from './lifecycle.js';
 import { ensureDaemon } from '../../daemon/manage.js';
@@ -68,8 +55,8 @@ export async function reshapeNodeAsync(nodeId, opts = {}, beforePersist) {
  *  `developer.orchestrator`) and optionally also making it resident. Idempotent:
  *  re-promoting just rewrites the spec. Seeds a roadmap SCAFFOLD if absent (a
  *  boss with no map is a failure mode) — no goal is forced here; authoring the
- *  goal + roadmap is the node's next act. The transition guidance is injected
- *  centrally by the persona injector at the next turn boundary, not returned. */
+ *  goal + roadmap is the node's next act. Pending context delivery is owned by
+ *  the broker provider gate, not this command. */
 export function promote(nodeId, opts = {}) {
     const node = getNode(nodeId);
     if (node === null)

package/dist/core/runtime/revive.js

@@ -22,7 +22,7 @@
 // reviveNode remains the ONLY sanctioned launcher of the node engine.
 import { existsSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
-import { getNode, updateNode, clearPid, recordPid, fullName, subscribersOf, } from '../canvas/index.js';
+import { findNodeBySessionFile, getNode, updateNode, clearPid, recordPid, fullName, subscribersOf, } from '../canvas/index.js';
 import { cancelCronsOnWake } from '../canvas/crons.js';
 import { transition } from './lifecycle.js';
 import { fanDoctrineWake } from './close.js';
@@ -33,7 +33,7 @@ import { readRoadmap } from './roadmap.js';
 import { headlessBrokerHost } from './host.js';
 import { boundFleet } from './fleet.js';
 import { clearFault, beginBootFaultAttempt } from './fault.js';
-import { clearInjectedDocs } from '../substrate/injected-store.js';
+import { clearContextExposureState, initializeForkContextExposure, } from '../substrate/injected-store.js';
 import { rootOfSpine } from './nodes.js';
 import { isReviewCompanionBound } from '../review/companion.js';
 import { assertProfileActive } from '../profiles/manifest.js';
@@ -153,16 +153,22 @@ export function reviveNode(nodeId, opts) {
         meta.pi_session_file = null;
     }
     // An ordinary fork remains a birth until session_start records the child
-    // session. Replaying the immutable branch on every pre-bind retry prevents a
-    // crash from silently turning it into a fresh conversation.
-    const forkBirthPending = typeof meta.fork_from === 'string' &&
-        isAbsolute(meta.fork_from) &&
-        meta.pi_session_id == null;
-    if (forkBirthPending && !existsSync(meta.fork_from)) {
+    // session. Every retry replays the resolved immutable source file.
+    const forkBirthUnbound = meta.fork_from != null && meta.pi_session_id == null;
+    const forkSourceFile = meta.fork_source_file;
+    if (forkBirthUnbound && (typeof forkSourceFile !== 'string' || !isAbsolute(forkSourceFile))) {
+        throw new InputError({
+            error: 'fork_source_invalid',
+            message: `${nodeId} cannot be revived — its resolved fork source file is missing or invalid.`,
+            next: `Restore the node's fork source metadata, then retry \`crtr node lifecycle revive ${nodeId}\`.`,
+        });
+    }
+    const forkBirthPending = forkBirthUnbound && typeof forkSourceFile === 'string';
+    if (forkBirthPending && !existsSync(forkSourceFile)) {
         throw new InputError({
             error: 'fork_from_missing',
-            message: `${nodeId} cannot be revived — its fork source no longer exists: ${meta.fork_from}`,
-            next: `Restore ${meta.fork_from}, or update the node's fork source, then retry \`crtr node lifecycle revive ${nodeId}\`.`,
+            message: `${nodeId} cannot be revived — its fork source no longer exists: ${forkSourceFile}`,
+            next: `Restore ${forkSourceFile}, or update the node's fork source, then retry \`crtr node lifecycle revive ${nodeId}\`.`,
         });
     }
     // Every (re)launch is a new cycle — bump the counter so CRTR_CYCLES and the
@@ -220,10 +226,10 @@ export function reviveNode(nodeId, opts) {
     if (forkBirthPending) {
         const goal = readGoal(nodeId);
         inv = buildPiArgv(meta, {
-            forkFrom: meta.fork_from,
+            forkFrom: forkSourceFile,
             ...(goal != null && goal !== '' ? { prompt: goal } : {}),
         });
-        clearInjectedDocs(nodeId);
+        initializeForkContextExposure(nodeId, findNodeBySessionFile(forkSourceFile)?.node_id ?? null);
     }
     else if (resuming) {
         inv = buildPiArgv(meta, {
@@ -241,7 +247,7 @@ export function reviveNode(nodeId, opts) {
         // interactive node boots promptless and takes no turn at all.
         const goal = readGoal(nodeId)?.trim();
         inv = buildPiArgv(meta, goal !== undefined && goal !== '' ? { prompt: goal } : {});
-        clearInjectedDocs(nodeId);
+        clearContextExposureState(nodeId);
     }
     else {
         // Fresh or cycling: drain the one-shot bearings, then build the kickoff.
@@ -254,10 +260,7 @@ export function reviveNode(nodeId, opts) {
             ...resume,
             prompt: buildReviveKickoff(meta, bearings, opts.wakeReason === 'runtime-restart-abort' ? undefined : opts.wakeReason),
         });
-        // Fresh or cycling revive starts a NEW LLM context — reset the on-read doc
-        // dedup so it surfaces docs from scratch (a true resume above instead KEEPS
-        // the persisted set, continuing the same transcript).
-        clearInjectedDocs(nodeId);
+        clearContextExposureState(nodeId);
     }
     // Every lifecycle launch emits the authoritative spine root rather than
     // inheriting whichever node happened to invoke reviveNode.

package/dist/core/runtime/spawn.js

@@ -21,7 +21,7 @@ import { writeGoal } from './kickoff.js';
 import { appendSituationalContext, formatSituationalProse } from './situational-context.js';
 import { hasRoadmap, seedRoadmap } from './roadmap.js';
 import { buildWakeBearings } from './bearings.js';
-import { contextDir, getNode, fullName, recordPid } from '../canvas/index.js';
+import { canonicalSessionFile, contextDir, findNodeBySessionFile, getNode, fullName, recordPid } from '../canvas/index.js';
 import { jobDir } from '../canvas/paths.js';
 import { openViewerWindow, focusOf, windowOfPane, currentTmux, focusWindow, } from './placement.js';
 import { waitForBrokerViewSocket } from './placement-tmux.js';
@@ -33,6 +33,7 @@ import { ensureDaemon } from '../../daemon/manage.js';
 import { readConfig } from '../config.js';
 import { modelRequestFromConfig, unregisteredConcreteModel } from '../model-routes.js';
 import { openModelRegistry } from './model-registry.js';
+import { initializeForkContextExposure } from '../substrate/injected-store.js';
 // ---------------------------------------------------------------------------
 // Shared broker-launch wrapper — catch launch/preflight failures at the call
 // site, mark the node crashed, then rethrow a clear error.
@@ -112,7 +113,7 @@ function resolveSessionUuid(uuid) {
             next: 'Pass the full session uuid or an absolute .jsonl path to disambiguate.',
         });
     }
-    return hit[0].path;
+    return canonicalSessionFile(hit[0].path);
 }
 /** Resolve a `--fork-from` value to an ABSOLUTE `.jsonl` source path for the
  *  broker fork (`SessionManager.forkFrom`, which loads a file — never a bare id).
@@ -127,7 +128,7 @@ export function resolveForkSource(value) {
     // A path (contains `/` or ends `.jsonl`) is a session file — ensure it is
     // ABSOLUTE so the broker, launched in a different cwd, still resolves it.
     if (v.includes('/') || v.endsWith('.jsonl')) {
-        return isAbsolute(v) ? v : resolve(process.cwd(), v);
+        return canonicalSessionFile(isAbsolute(v) ? v : resolve(process.cwd(), v));
     }
     // A live node id — fork from the conversation it has accumulated. Its captured
     // session FILE is absolute; the broker cannot fork a bare session id.
@@ -139,7 +140,7 @@ export function resolveForkSource(value) {
                 next: 'Pick a node that has captured a session, or drop --fork-from.',
             });
         }
-        return src;
+        return canonicalSessionFile(src);
     }
     // Not a known node — a bare/partial pi session uuid; resolve it to an absolute
     // .jsonl (the broker fork won't resolve a uuid).
@@ -242,6 +243,9 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
     const preflightLaunch = (await buildLaunchSpecAsync(opts.kind, mode, { lifecycle, hasManager: !root, model: opts.model, cwd: opts.cwd, profileId })).launch;
     await assertLaunchModelRegistered(requestFromLaunch(preflightLaunch), { cwd: opts.cwd, profileId });
     const forkFrom = opts.forkFrom !== undefined ? resolveForkSource(opts.forkFrom) : undefined;
+    const forkSourceNodeId = forkFrom === undefined
+        ? null
+        : findNodeBySessionFile(forkFrom)?.node_id ?? null;
     let managedWorktree;
     let spawnCwd = opts.cwd;
     try {
@@ -274,15 +278,22 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
             parent: root ? null : spawner,
             spawnedBy: root ? (spawner ?? undefined) : undefined,
             profile_id: profileId,
-            // Persist the RAW fork reference (not the resolved path) as provenance, so
-            // the boot intro can detect this is a fork and re-assert the node's own
-            // identity over the source's copied-in conversation.
             forkFrom: opts.forkFrom,
+            forkSourceFile: forkFrom,
             modelOverride: opts.model,
             ...(managedWorktree !== undefined ? { managedWorktree } : {}),
             ...(nodeId !== undefined ? { nodeId } : {}),
             launch,
         });
+        if (opts.forkFrom !== undefined) {
+            try {
+                initializeForkContextExposure(meta.node_id, forkSourceNodeId);
+            }
+            catch (error) {
+                transition(meta.node_id, 'crash');
+                throw error;
+            }
+        }
         // Persist the task as the child's goal for a fresh revive to re-read.
         writeGoal(meta.node_id, opts.prompt);
         // Hidden ambient context, written BEFORE the engine launches so canvas-

package/dist/core/runtime/tmux-bindings.js

@@ -19,9 +19,8 @@ const LEAF_MENU_ACTIONS = {
     'crtr.tmux.menu.promote': { description: 'promote to orchestrator', action: { kind: 'keys', keys: '/promote' } },
     'crtr.tmux.menu.resume': { description: 'find node', action: { kind: 'keys', keys: '/resume-node' } },
     'crtr.tmux.menu.fork': { description: 'fork into idle root', action: { kind: 'direct', run: 'node fork --pane {pane}' } },
-    // Mode demote is the mirror of `/promote`: `node config` is the durable
-    // attribute setter, and the persona injector delivers the hands-on-again
-    // guidance at the node's next turn boundary.
+    // Mode demote is the mirror of `/promote`: `node config` persists the change;
+    // the broker appends its pending context before the next provider response.
     'crtr.tmux.menu.demote-mode': { description: 'demote to base node', action: { kind: 'command', run: 'node config --mode base --pane {pane}' } },
     'crtr.tmux.menu.demote': { description: 'demote to terminal (finish when done)', action: { kind: 'command', run: 'node lifecycle demote --pane {pane}' } },
     'crtr.tmux.menu.make-resident': { description: 'make resident (interactable)', action: { kind: 'command', run: 'node config --lifecycle resident --pane {pane}' } },

package/dist/core/runtime/warm-pool.js

@@ -17,9 +17,8 @@
 //     `promote`/`yield --kind` polymorph rewrites them, so the next revive comes
 //     back as the claimed persona and `nodeEnv`'s CRTR_KIND/CRTR_MODE flip for
 //     anything the live process spawns.
-//   • persona_ack — stamped to the claimed {mode,lifecycle}. Without it the
-//     persona injector (runtime/persona.ts) reads drift on the first turn and
-//     tells a brand-new node its persona just changed.
+//   • persona_ack — stamped to the claimed persona so a newborn has no pending
+//     transition on its first turn.
 //   • model — swapped over the live broker socket (`setModelLive`, the same
 //     seam provider rotation uses). A model swap that cannot reach the broker
 //     FAILS the claim: the spare is closed and the caller cold-spawns, because
@@ -133,7 +132,7 @@ export async function claimWarmNode(request) {
         // back as the spare's persona.
         launch: recipe.launch,
         // A newborn must not be told its persona just changed.
-        persona_ack: { mode: request.mode, lifecycle: 'resident' },
+        persona_ack: { kind: request.kind, mode: request.mode, lifecycle: 'resident' },
         ...(request.model !== null ? { model_override: request.model } : {}),
     });
     // Bearings FIRST, before any other delivery: a spare mints without them (see

package/dist/core/scope.js

@@ -6,6 +6,7 @@ import { assetRoot } from './asset-root.js';
 import { usage } from './errors.js';
 import { loadProfileManifest } from './profiles/manifest.js';
 import { realpathOrSelf } from './fs-utils.js';
+import { resetRepositoryAssociationCache } from './memory/repository-association.js';
 /** The ceiling a project root carries when no profile relationship contributes
  *  it — the top rung, i.e. no cap at all. */
 export const NEUTRAL_PROJECT_MEMORY = 'content';
@@ -248,4 +249,5 @@ export function listScopes(scopeArg) {
 }
 export function resetScopeCache() {
     scopeRootsCache.clear();
+    resetRepositoryAssociationCache();
 }

package/dist/core/self-update.d.ts

@@ -7,8 +7,6 @@ export declare function selfCheck(): {
     current: string;
     latest: string;
 } | null;
-/** Pull updates for all installed marketplaces and standalone plugins. */
-export declare function contentUpdate(): void;
 export interface ContentUpdateEntry {
     name: string;
     kind: 'marketplace' | 'plugin';

package/dist/core/self-update.js

@@ -6,10 +6,8 @@ import { fileURLToPath } from 'node:url';
 import { join, dirname } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { listAllPlugins, listAllMarketplaces } from './resolver.js';
-import { pull, fetch, currentSha, remoteSha } from './git.js';
-import { updateState } from './config.js';
-import { nowIso } from './fs-utils.js';
-import { general, network } from './errors.js';
+import { fetch, currentSha, remoteSha } from './git.js';
+import { general } from './errors.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // src/core/self-update.ts → up to src/ → up to pkg root
@@ -39,37 +37,6 @@ export function selfCheck() {
     const current = currentVersion();
     return { current, latest };
 }
-/** Pull updates for all installed marketplaces and standalone plugins. */
-export function contentUpdate() {
-    const marketplaces = listAllMarketplaces();
-    for (const mkt of marketplaces) {
-        const res = pull(mkt.root);
-        if (res.status !== 0) {
-            throw network(`git pull failed for marketplace ${mkt.name}: ${res.stderr.trim()}`);
-        }
-        updateState(mkt.scope, (s) => {
-            if (!s.marketplaces[mkt.name])
-                s.marketplaces[mkt.name] = {};
-            s.marketplaces[mkt.name].last_updated = nowIso();
-        });
-    }
-    const plugins = listAllPlugins();
-    for (const plugin of plugins) {
-        if (!plugin.enabled)
-            continue;
-        if (plugin.sourceMarketplace)
-            continue;
-        const res = pull(plugin.root);
-        if (res.status !== 0) {
-            throw network(`git pull failed for plugin ${plugin.name}: ${res.stderr.trim()}`);
-        }
-        updateState(plugin.scope, (s) => {
-            if (!s.plugins[plugin.name])
-                s.plugins[plugin.name] = {};
-            s.plugins[plugin.name].last_updated = nowIso();
-        });
-    }
-}
 /** Check whether any marketplace/plugin has updates available.
  *  Returns per-item status without applying anything. */
 export function contentCheck() {

package/dist/core/substrate/__tests__/surface-match-memory-read.test.d.ts

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

package/dist/core/substrate/__tests__/surface-match-memory-read.test.js

@@ -0,0 +1,28 @@
+// Regression: memory-read matching must consume ONLY the resolved doc's
+// exact canonical name — the hard-cut identity rule forbids a mount-stripped
+// alias (or any other alias) from firing an unrelated carrier's route.
+//
+// Run: node --conditions=crtr-src --import tsx/esm --test src/core/substrate/__tests__/surface-match-memory-read.test.ts
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { matchesMemoryReadEntry } from '../surface-match.js';
+function entry(match) {
+    return { on: 'memory-read', at: 'preview', match };
+}
+test('a carrier routed at the mount-stripped local name does not fire for the plugin-qualified canonical read', () => {
+    // Authored for an unrelated ordinary doc named "topic" — must not fire
+    // when the resolved doc is actually the plugin doc "plug/topic".
+    assert.equal(matchesMemoryReadEntry(entry(['topic']), '', null, 'plug/topic'), false);
+});
+test('a carrier routed at the plugin-qualified canonical name still fires for that exact read', () => {
+    assert.equal(matchesMemoryReadEntry(entry(['plug/topic']), '', null, 'plug/topic'), true);
+});
+test('a carrier routed at the canonical name still fires for an ordinary (non-plugin) read', () => {
+    assert.equal(matchesMemoryReadEntry(entry(['topic']), '', null, 'topic'), true);
+});
+test('a directory-relative `./` route still anchors to the routing anchor of the canonical name', () => {
+    // Legitimate routing anchor / directory semantics preserved: a carrier
+    // fronting `plug/dir` still matches its own member by relative glob.
+    assert.equal(matchesMemoryReadEntry(entry(['./member']), 'plug/dir', null, 'plug/dir/member'), true);
+    assert.equal(matchesMemoryReadEntry(entry(['./member']), 'plug/dir', null, 'member'), false);
+});

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

@@ -3,8 +3,8 @@ export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc, Surfa
 export { lintSubstrateFrontmatter, lintSubstrateSchema, lintSubstrateSurfaces, parsedSubstrateSurfaces } from './frontmatter-validation.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 { clearContextExposureState, cloneContextExposureState, cloneTranscriptExposureState, contentExposureIdentity, contextExposureStatesEqual, documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, freezePreferenceSnapshot, hasTranscriptExposure, initializeForkContextExposure, loadContextExposureState, mergeContextExposureState, registerDocumentExposure, registerExposure, replaceContextExposureState, saveContextExposureState, sharedContextExposureState, } from './injected-store.js';
+export type { ContextExposureState, ExposureSource, ExposureTarget } from './injected-store.js';
 export { scopeForCwd, profileNameFor } from './subject-fields.js';
 export type { NodeConfigSubject } from './subject-fields.js';
 export { spineDepth, assembleNodeSubject } from './subject.js';

package/dist/core/substrate/index.js

@@ -19,7 +19,7 @@ resolveDocName, } from './schema.js';
 export { lintSubstrateFrontmatter, lintSubstrateSchema, lintSubstrateSurfaces, parsedSubstrateSurfaces } from './frontmatter-validation.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 { clearContextExposureState, cloneContextExposureState, cloneTranscriptExposureState, contentExposureIdentity, contextExposureStatesEqual, documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, freezePreferenceSnapshot, hasTranscriptExposure, initializeForkContextExposure, loadContextExposureState, mergeContextExposureState, registerDocumentExposure, registerExposure, replaceContextExposureState, saveContextExposureState, sharedContextExposureState, } from './injected-store.js';
 export { scopeForCwd, profileNameFor } from './subject-fields.js';
 export { spineDepth, assembleNodeSubject } from './subject.js';
 export { gatePasses } from './gate.js';

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

@@ -1,28 +1,44 @@
 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): 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;
+export type ExposureSource = 'system' | 'transcript';
+interface ExposureRanks {
+    system?: number;
+    transcript?: number;
+}
+/** Memory visible to the currently loaded LLM context. */
+export interface ContextExposureState {
+    /** Byte-stable preference splice for this context. */
+    preferenceSnapshot: string | null;
+    /** Canonical identity → ranks loaded from the system and transcript snapshots. */
+    exposures: Map<string, ExposureRanks>;
+}
+export interface ExposureTarget {
+    state: ContextExposureState;
+    source: ExposureSource;
+}
+export declare function emptyContextExposureState(): ContextExposureState;
+export declare function exposureTarget(state: ContextExposureState, source: ExposureSource): ExposureTarget;
+export declare function exposedAtOrAbove(state: ContextExposureState, identity: string, rung: Rung): boolean;
+/** The sole delivery mutation: max-fold one loaded identity into its source rank. */
+export declare function registerExposure(target: ExposureTarget, identity: string, rung: Rung): void;
+export declare function contentExposureIdentity(body: string): string | null;
+export declare function documentExposedAtOrAbove(state: ContextExposureState, path: string, body: string, rung: Rung): boolean;
+/** Register both the physical document and its non-empty content alias. */
+export declare function registerDocumentExposure(target: ExposureTarget, path: string, body: string, rung: Rung): void;
+export declare function freezePreferenceSnapshot(state: ContextExposureState, rendered: string): string;
+export declare function cloneContextExposureState(source: ContextExposureState): ContextExposureState;
+export declare function hasTranscriptExposure(state: ContextExposureState): boolean;
+/** The context copied into a fork excludes the source's system snapshot. */
+export declare function cloneTranscriptExposureState(source: ContextExposureState): ContextExposureState;
+export declare function replaceContextExposureState(target: ContextExposureState, source: ContextExposureState): void;
+export declare function contextExposureStatesEqual(left: ContextExposureState, right: ContextExposureState): boolean;
+/** Fold state written by another process into the live context state. */
+export declare function mergeContextExposureState(target: ContextExposureState, source: ContextExposureState): void;
+export declare function sharedContextExposureState(nodeId: string): ContextExposureState;
+/** v1/v2 ranks predate provenance and conservatively become transcript exposure. */
+export declare function loadContextExposureState(nodeId: string): ContextExposureState;
+export declare function saveContextExposureState(nodeId: string, state: ContextExposureState): void;
+/** Clear in place so every extension closure observes the new context boundary. */
+export declare function clearContextExposureState(nodeId: string): void;
+/** Seed a fork with only context copied in the source transcript. */
+export declare function initializeForkContextExposure(destinationNodeId: string, sourceNodeId: string | null): void;
+export {};