@north-light/crouter 0.3.161 → 0.3.163

package/dist/core/subscription-state.d.ts

@@ -1,11 +1,13 @@
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 export declare const ANTHROPIC_PROVIDER_ID = "anthropic";
 export declare const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
 export declare const INVALID_REFRESH_TOKEN_BACKOFF_MS: number;
 export type ManagedProviderId = typeof ANTHROPIC_PROVIDER_ID | typeof OPENAI_CODEX_PROVIDER_ID;
-export type LadderProviderId = "anthropic" | "openai";
 export type ModelStrength = "ultra" | "strong" | "medium" | "light";
+export type RotationConfig = {
+    defaultFallbackStrength?: ModelStrength;
+    revertWhenAvailable?: boolean;
+};
+type RotationConfigUpdate = RotationConfig;
 export type SubscriptionCredential = {
     label: string;
     refresh: string;
@@ -17,27 +19,6 @@ export type SubscriptionCredential = {
     authFailure?: "invalid_grant";
     accountId?: string;
 };
-export type ModelRef = {
-    providerId: ManagedProviderId;
-    modelId: string;
-};
-export type RotationConfig = {
-    defaultFallbackStrength?: ModelStrength;
-    revertWhenAvailable?: boolean;
-    preferredModel?: ModelRef;
-};
-type RotationConfigUpdate = {
-    defaultFallbackStrength?: ModelStrength;
-    revertWhenAvailable?: boolean;
-    preferredModel?: ModelRef | null;
-};
-export type FallbackTarget = {
-    providerId: ManagedProviderId;
-    modelId: string;
-    label: string;
-    strength: ModelStrength;
-    thinkingLevel?: ThinkingLevel;
-};
 /** A concrete provider/model considered for either broker launch or turn-time rotation. */
 export type ProviderCandidate = {
     providerId: string;
@@ -49,6 +30,12 @@ export type ProviderCandidate = {
     coolingUntil?: number;
     /** False when this candidate may only be selected by an explicit request, never as fallback. */
     automaticFallback?: boolean;
+    /** Route provenance carried through selection diagnostics. */
+    routeId?: string;
+    credentialSource?: string;
+    family?: string;
+    strength?: ModelStrength;
+    rank?: number;
 };
 export type ProviderCandidateRejection = "unregistered" | "non-managed-fallback" | "unauthenticated" | "cooling";
 /**
@@ -72,12 +59,6 @@ export declare function resolveProviderCandidates(candidates: readonly ProviderC
     }>;
 };
 export declare function isManagedProvider(providerId: string | undefined): providerId is ManagedProviderId;
-/** The `modelLadders` CONFIG key for a runtime provider id -- `openai-codex`
- *  (the runtime/auth id) maps to the `openai` ladder key used in
- *  ~/.crouter/config.json. Callers building a repair command that a user can
- *  paste into `crtr sys config set modelLadders.<key>...` must use THIS key,
- *  not the runtime provider id. */
-export declare function getLadderProviderId(providerId: ManagedProviderId): LadderProviderId;
 export declare function getProviderLabel(providerId: ManagedProviderId): string;
 export declare function mutateSubscriptionPool(providerId: ManagedProviderId, fn: (pool: SubscriptionCredential[], assertLockHeld: () => void) => SubscriptionCredential[] | undefined | Promise<SubscriptionCredential[] | undefined>): Promise<SubscriptionCredential[]>;
 export declare function refreshSubscriptionCredential(providerId: ManagedProviderId, label: string, exchange: (refreshToken: string) => Promise<{
@@ -118,6 +99,7 @@ export declare function commitManagedLogin(providerId: ManagedProviderId, label:
     lastRateLimitedAt: number;
     autoLabel?: boolean;
 }): Promise<SubscriptionCredential[]>;
+export declare function removeAllManagedAccounts(providerId: ManagedProviderId): Promise<number>;
 export declare function removeManagedProvider(providerId: ManagedProviderId, label?: string): Promise<SubscriptionCredential[]>;
 export declare function removeSubscription(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
 export declare function promoteSubscription(providerId: ManagedProviderId, ref: string): Promise<SubscriptionCredential[]>;
@@ -128,11 +110,5 @@ export declare function markSubscriptionSuccess(providerId: ManagedProviderId, r
 export declare function parseRetryAfterHeader(value: string | undefined, now?: number): number | undefined;
 export declare function readRotationConfig(): RotationConfig;
 export declare function writeRotationConfig(next: RotationConfigUpdate): RotationConfig;
-export declare function clearPreferredModel(): RotationConfig;
-export declare function rememberPreferredModel(model: ModelRef): RotationConfig;
-export declare function resolveFallbackTarget(currentProviderId: ManagedProviderId, currentModelId?: string, config?: RotationConfig, currentThinkingLevel?: string): FallbackTarget | undefined;
-export declare function shouldRestorePreferredModel(config?: RotationConfig, now?: number): boolean;
-export declare function restorePreferredModelIfPossible(piApi: ExtensionAPI, ctx: Pick<ExtensionContext, "model" | "modelRegistry">): Promise<boolean>;
-export declare function switchToFallbackIfPossible(piApi: ExtensionAPI, ctx: Pick<ExtensionContext, "model" | "modelRegistry">, preferredModel?: ModelRef | undefined): Promise<FallbackTarget | undefined>;
 export declare function formatStatusLine(providerId: ManagedProviderId, now?: number): string;
 export {};

package/dist/core/subscription-state.js

@@ -1,6 +1,5 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { defaultModelLaddersConfig } from "../types.js";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { LockedJsonFile } from "./locked-file.js";
@@ -61,19 +60,14 @@ function agentDir() {
 function rotationConfigFile() {
     return join(agentDir(), "provider-rotation.json");
 }
-function crouterConfigFile() {
-    return join(homedir(), ".crouter", "config.json");
-}
 const DEFAULT_FALLBACK_STRENGTH = "strong";
 const PROVIDERS = {
     [ANTHROPIC_PROVIDER_ID]: {
         label: "Claude",
-        ladderProviderId: "anthropic",
         poolFileName: "anthropic-subscriptions.json",
     },
     [OPENAI_CODEX_PROVIDER_ID]: {
         label: "OpenAI Codex",
-        ladderProviderId: "openai",
         poolFileName: "openai-codex-subscriptions.json",
     },
 };
@@ -184,9 +178,6 @@ function traceDroppedRows(providerId, stored, normalized) {
         return;
     process.stderr.write(`[subscription-pool] ${getProviderLabel(providerId)}: dropping ${stored.length - normalized.length} stored row(s) with no label or no token pair\n`);
 }
-function getCurrentModelRef(model) {
-    return isManagedProvider(model?.provider) ? { providerId: model.provider, modelId: model.id } : undefined;
-}
 // A refreshed/modified token set is only storable when it carries BOTH halves and a usable
 // expiry. Persisting a partial one is silently destructive: `JSON.stringify` drops the missing
 // key, and `normalizeCredential` (which requires refresh AND access together) then discards the
@@ -247,14 +238,6 @@ function logCredentialSetChange(providerId, base, next) {
 export function isManagedProvider(providerId) {
     return providerId === ANTHROPIC_PROVIDER_ID || providerId === OPENAI_CODEX_PROVIDER_ID;
 }
-/** The `modelLadders` CONFIG key for a runtime provider id -- `openai-codex`
- *  (the runtime/auth id) maps to the `openai` ladder key used in
- *  ~/.crouter/config.json. Callers building a repair command that a user can
- *  paste into `crtr sys config set modelLadders.<key>...` must use THIS key,
- *  not the runtime provider id. */
-export function getLadderProviderId(providerId) {
-    return PROVIDERS[providerId].ladderProviderId;
-}
 export function getProviderLabel(providerId) {
     return PROVIDERS[providerId].label;
 }
@@ -603,14 +586,26 @@ export async function commitManagedLogin(providerId, label, credential) {
         return merged;
     });
 }
+// Remove every account for one managed provider through a single locked transform. The
+// returned count belongs to that locked snapshot, so callers do not race a concurrent login.
+export async function removeAllManagedAccounts(providerId) {
+    let removed = 0;
+    await mutateSubscriptionPool(providerId, (pool) => {
+        removed = pool.length;
+        return [];
+    });
+    return removed;
+}
 // Coordinated removal for the human UI. Removes a single account when `label` is given; the ENTIRE
-// provider (every pool account) when `label` is omitted — always through removeManagedAccount. UI
+// provider (every pool account) when `label` is omitted — always through a pool transform. UI
 // must NEVER reach for a raw auth.json delete on a managed provider: that strips a file pi no
 // longer reads for managed providers and orphans the whole pool.
 export async function removeManagedProvider(providerId, label) {
+    if (label === undefined) {
+        await removeAllManagedAccounts(providerId);
+        return [];
+    }
     return mutateSubscriptionPool(providerId, (pool) => {
-        if (label === undefined)
-            return [];
         const index = resolveCredentialIndex(pool, label);
         if (index === -1)
             throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${label}`);
@@ -701,9 +696,6 @@ export async function markSubscriptionSuccess(providerId, ref, attemptAt = Date.
         return next;
     });
 }
-function findAvailableSubscription(providerId, now = Date.now()) {
-    return readSubscriptionPool(providerId).find((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
-}
 export function parseRetryAfterHeader(value, now = Date.now()) {
     if (!value)
         return undefined;
@@ -716,102 +708,11 @@ export function parseRetryAfterHeader(value, now = Date.now()) {
     const parsed = Date.parse(trimmed);
     return Number.isFinite(parsed) ? Math.max(0, parsed - now) : undefined;
 }
-function thinkingLevelOfRef(ref) {
-    const match = ref.trim().match(/:(thinking|off|minimal|low|medium|high|xhigh|max)$/i);
-    if (!match)
-        return undefined;
-    const level = match[1].toLowerCase();
-    return level === "off" || level === "thinking" ? undefined : level;
-}
-function normalizeModelRef(ref) {
-    return ref
-        .trim()
-        .replace(/^[^/]+\//, "")
-        .replace(/:(?:thinking|off|minimal|low|medium|high|xhigh|max)$/i, "")
-        .toLowerCase();
-}
-function splitModelRef(ref) {
-    const trimmed = ref.trim();
-    const slash = trimmed.indexOf("/");
-    const providerId = slash === -1 ? OPENAI_CODEX_PROVIDER_ID : trimmed.slice(0, slash).trim();
-    if (!isManagedProvider(providerId)) {
-        throw new Error(`Unsupported fallback provider: ${providerId}`);
-    }
-    const rawModelId = slash === -1 ? trimmed : trimmed.slice(slash + 1).trim();
-    const thinkingMatch = rawModelId.match(/^(.*?)(?::(thinking|off|minimal|low|medium|high|xhigh|max))$/i);
-    return {
-        providerId,
-        modelId: thinkingMatch ? thinkingMatch[1] : rawModelId,
-        label: `${providerId}/${thinkingMatch ? thinkingMatch[1] : rawModelId}${thinkingMatch?.[2] ? `:${thinkingMatch[2].toLowerCase()}` : ""}`,
-        strength: DEFAULT_FALLBACK_STRENGTH,
-        thinkingLevel: thinkingMatch?.[2] && thinkingMatch[2].toLowerCase() !== "off" && thinkingMatch[2].toLowerCase() !== "thinking"
-            ? thinkingMatch[2].toLowerCase()
-            : undefined,
-    };
-}
-// Layers ~/.crouter/config.json's `modelLadders` (if any) OVER crouter's
-// builtin ladder (`defaultModelLaddersConfig()`, src/types.ts — imported
-// directly: this package's canonical home is the crouter tree, so the
-// relative import always resolves, to dist/types.js at runtime), per
-// provider/strength — mirroring crouter's own
-// `mergeModelLadders` (src/core/config.ts), which is what a node's launcher
-// actually resolves models from. Without this fallback, a config-less user
-// (the common case: fresh install, no ~/.crouter/config.json) saw an EMPTY
-// ladder here while crtr itself launched them on the builtin defaults —
-// rotation could then never resolve a strength tier or a cross-provider
-// fallback for a model it was already running. Always returns a fully
-// populated ladder for both providers; a config.json override only replaces
-// the specific strengths it sets.
-function readModelLadders() {
-    const config = readJsonFile(crouterConfigFile());
-    const overrides = config?.modelLadders;
-    const builtin = defaultModelLaddersConfig();
-    const result = {};
-    for (const provider of ["anthropic", "openai"]) {
-        const normalized = { ...builtin[provider] };
-        const override = overrides?.[provider];
-        if (override) {
-            for (const strength of ["ultra", "strong", "medium", "light"]) {
-                const value = typeof override[strength] === "string" ? override[strength]?.trim() : "";
-                if (value)
-                    normalized[strength] = value;
-            }
-        }
-        result[provider] = normalized;
-    }
-    return result;
-}
-function findStrengthForModelId(providerId, modelId, defaultStrength, ladders = readModelLadders(), currentThinkingLevel) {
-    const source = ladders?.[PROVIDERS[providerId].ladderProviderId];
-    const bareId = modelId ? normalizeModelRef(modelId) : undefined;
-    if (!source || !bareId)
-        return undefined;
-    const matches = [];
-    for (const strength of ["ultra", "strong", "medium", "light"]) {
-        const ref = source[strength];
-        if (ref && normalizeModelRef(ref) === bareId)
-            matches.push(strength);
-    }
-    if (matches.length === 0)
-        return undefined;
-    // Rungs that share a bare model id (e.g. gpt-5.6-sol:max vs gpt-5.6-sol:high) are
-    // disambiguated by the live reasoning level so an ultra run doesn't collapse to strong.
-    if (matches.length > 1 && currentThinkingLevel) {
-        const exact = matches.find((strength) => thinkingLevelOfRef(source[strength]) === currentThinkingLevel);
-        if (exact)
-            return exact;
-    }
-    return matches.includes(defaultStrength) ? defaultStrength : matches[0];
-}
 export function readRotationConfig() {
     const raw = readJsonFile(rotationConfigFile()) ?? {};
-    const preferredModel = raw.preferredModel && isManagedProvider(raw.preferredModel.providerId) && typeof raw.preferredModel.modelId === "string"
-        ? { providerId: raw.preferredModel.providerId, modelId: raw.preferredModel.modelId.trim() }
-        : undefined;
     return {
         defaultFallbackStrength: normalizeStrength(raw.defaultFallbackStrength) ?? DEFAULT_FALLBACK_STRENGTH,
         revertWhenAvailable: raw.revertWhenAvailable ?? true,
-        preferredModel,
     };
 }
 export function writeRotationConfig(next) {
@@ -819,100 +720,15 @@ export function writeRotationConfig(next) {
     const merged = {
         defaultFallbackStrength: normalizeStrength(next.defaultFallbackStrength) ?? current.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH,
         revertWhenAvailable: next.revertWhenAvailable ?? current.revertWhenAvailable ?? true,
-        preferredModel: Object.prototype.hasOwnProperty.call(next, "preferredModel")
-            ? next.preferredModel || undefined
-            : current.preferredModel,
     };
     writeJsonFile(rotationConfigFile(), merged);
     return merged;
 }
-export function clearPreferredModel() {
-    return writeRotationConfig({ preferredModel: null });
-}
-export function rememberPreferredModel(model) {
-    return writeRotationConfig({ preferredModel: model });
-}
-// `readModelLadders()` always fills both providers from the builtin defaults, so this
-// only returns undefined (never throws) in the defensive case where a rung is still
-// genuinely missing; callers must treat that as a graceful "no fallback available" case
-// rather than a config error to surface mid-turn.
-export function resolveFallbackTarget(currentProviderId, currentModelId, config = readRotationConfig(), currentThinkingLevel) {
-    const ladders = readModelLadders();
-    const defaultStrength = config.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH;
-    const sourceStrength = findStrengthForModelId(currentProviderId, currentModelId, defaultStrength, ladders, currentThinkingLevel);
-    const strength = sourceStrength ?? defaultStrength;
-    const targetProvider = currentProviderId === ANTHROPIC_PROVIDER_ID ? OPENAI_CODEX_PROVIDER_ID : ANTHROPIC_PROVIDER_ID;
-    const targetLadder = ladders?.[PROVIDERS[targetProvider].ladderProviderId];
-    const candidates = strength === defaultStrength ? [strength] : [strength, defaultStrength];
-    const fallbackRef = candidates.map((candidate) => targetLadder?.[candidate]).find((ref) => typeof ref === "string" && ref.trim().length > 0);
-    if (!fallbackRef) {
-        return undefined;
-    }
-    const parsed = splitModelRef(fallbackRef);
-    const resolvedStrength = candidates.find((candidate) => targetLadder?.[candidate] === fallbackRef) ?? strength;
-    return { ...parsed, strength: resolvedStrength };
-}
-export function shouldRestorePreferredModel(config = readRotationConfig(), now = Date.now()) {
-    if (!config.revertWhenAvailable || !config.preferredModel)
-        return false;
-    return Boolean(findAvailableSubscription(config.preferredModel.providerId, now));
-}
-export async function restorePreferredModelIfPossible(piApi, ctx) {
-    const config = readRotationConfig();
-    if (!shouldRestorePreferredModel(config, Date.now()))
-        return false;
-    const preferred = config.preferredModel;
-    if (!preferred)
-        return false;
-    const current = getCurrentModelRef(ctx.model);
-    if (current?.providerId === preferred.providerId && current.modelId === preferred.modelId) {
-        clearPreferredModel();
-        return true;
-    }
-    const model = ctx.modelRegistry.find(preferred.providerId, preferred.modelId);
-    if (!model)
-        return false;
-    const switched = await piApi.setModel(model);
-    if (switched)
-        clearPreferredModel();
-    return switched;
-}
-export async function switchToFallbackIfPossible(piApi, ctx, preferredModel = getCurrentModelRef(ctx.model)) {
-    if (!preferredModel)
-        return undefined;
-    rememberPreferredModel(preferredModel);
-    const currentThinkingLevel = piApi.getThinkingLevel?.();
-    const target = resolveFallbackTarget(preferredModel.providerId, preferredModel.modelId, readRotationConfig(), currentThinkingLevel);
-    if (!target)
-        return undefined;
-    const current = getCurrentModelRef(ctx.model);
-    const model = ctx.modelRegistry.find(target.providerId, target.modelId);
-    if (!model)
-        return undefined;
-    if (current?.providerId !== target.providerId || current.modelId !== target.modelId) {
-        const switched = await piApi.setModel(model);
-        if (!switched) {
-            // `setModel` returns false when its target lacks configured auth and leaves
-            // the live model unchanged. A concurrent transition can still independently
-            // make THIS exact target current while this call is in flight, so re-read
-            // the live model and accept only when it now equals the target on both provider and
-            // model id; any other current model is a genuine failed switch.
-            const afterSwitch = getCurrentModelRef(ctx.model);
-            if (afterSwitch?.providerId !== target.providerId || afterSwitch.modelId !== target.modelId)
-                return undefined;
-        }
-    }
-    if (target.thinkingLevel)
-        piApi.setThinkingLevel(target.thinkingLevel);
-    return target;
-}
 export function formatStatusLine(providerId, now = Date.now()) {
     const pool = readSubscriptionPool(providerId);
-    const ready = pool.filter((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
+    const ready = pool.filter((entry) => entry.authFailure === undefined && (!entry.rateLimitedUntil || entry.rateLimitedUntil <= now));
     const label = getProviderLabel(providerId);
-    if (ready.length === 0) {
-        const fallback = resolveFallbackTarget(providerId, undefined, readRotationConfig());
-        return fallback ? `${label} pool exhausted -> ${fallback.label}` : `${label} pool exhausted (no fallback configured)`;
-    }
-    return `${label} ${ready[0]?.label ?? providerId} (${ready.length}/${pool.length} ready)`;
+    return ready.length === 0
+        ? `${label} pool exhausted`
+        : `${label} ${ready[0]?.label ?? providerId} (${ready.length}/${pool.length} ready)`;
 }

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

@@ -8,13 +8,10 @@ export declare function isIndexName(name: string): boolean;
 export declare function indexDirOf(name: string): string;
 /** Returns the display path corresponding to a canonical logical identifier. */
 export declare function displayName(name: string): string;
-/** The two visibility surfaces an INDEX can cap. */
-export type Surface = 'systemPromptVisibility' | 'fileReadVisibility';
 /** Build the dir → governing-INDEX map. Precedence is first-occurrence-wins, so
  *  callers MUST pass docs precedence-ordered (project > user > builtin) — the
  *  highest-precedence INDEX governs a dir, mirroring the memory resolver. */
 export declare function buildCeilingIndex(docs: SubstrateDoc[]): Map<string, SubstrateDoc>;
-/** A doc's effective rung on `surface` after applying every ancestor INDEX
- *  ceiling: min(own rung, each ancestor INDEX's rung). A `none` ancestor INDEX
- *  hides the whole subtree (min with none = none). */
-export declare function effectiveRung(doc: SubstrateDoc, ceil: Map<string, SubstrateDoc>, surface: Surface): Rung;
+/** A doc's effective system-prompt rung after applying every ancestor INDEX
+ * ceiling. A `none` ancestor hides the whole subtree from the boot catalog. */
+export declare function effectiveSystemPromptRung(doc: SubstrateDoc, ceil: Map<string, SubstrateDoc>): Rung;

package/dist/core/substrate/ceiling.js

@@ -1,16 +1,15 @@
-// ceiling.ts — canonical INDEX identifiers and the subtree rung ceiling.
+// ceiling.ts — canonical INDEX identifiers and the boot-catalog subtree ceiling.
 //
-// A directory index has the canonical logical identifier `<directory>/INDEX`
-// (`INDEX` at the root) and the same substrate frontmatter as any doc. Its rung
-// is a ceiling for every document in its subtree.
+// A directory INDEX has the canonical logical identifier `<directory>/INDEX`
+// (`INDEX` at the root). Its system-prompt rung caps every document in that
+// subtree while the boot catalog renders:
 //
 //   effective rung of a descendant = min(own rung, every ancestor INDEX's rung)
 //
-// So a directory's INDEX at `preview` lets its files surface at most at
-// `preview`; an INDEX at `none` hides the whole subtree. This is the single,
-// explicit mechanism for collapsing a directory in agent-facing surfaces (boot
-// render + on-read) — there is no parallel auto-hiding heuristic. See design
-// taste: `crtr memory read taste/document-substrate`.
+// A `preview` INDEX therefore lets its descendants surface at most at preview;
+// a `none` INDEX hides the subtree. File context does not use this ceiling:
+// every workspace/file match is an explicit `applies-to` route and renders at
+// the matched document's own file-read rung.
 import { rungRank } from './schema.js';
 /** The reserved basename (no extension) that marks a directory's index doc. */
 export const INDEX_NAME = 'INDEX';
@@ -55,15 +54,14 @@ function ancestorDirs(name) {
         out.push(parts.slice(0, i).join('/'));
     return out;
 }
-/** A doc's effective rung on `surface` after applying every ancestor INDEX
- *  ceiling: min(own rung, each ancestor INDEX's rung). A `none` ancestor INDEX
- *  hides the whole subtree (min with none = none). */
-export function effectiveRung(doc, ceil, surface) {
-    let rung = doc[surface];
+/** A doc's effective system-prompt rung after applying every ancestor INDEX
+ * ceiling. A `none` ancestor hides the whole subtree from the boot catalog. */
+export function effectiveSystemPromptRung(doc, ceil) {
+    let rung = doc.systemPromptVisibility;
     for (const dir of ancestorDirs(doc.name)) {
         const idx = ceil.get(dir);
         if (idx)
-            rung = minRung(rung, idx[surface]);
+            rung = minRung(rung, idx.systemPromptVisibility);
     }
     return rung;
 }

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

@@ -4,8 +4,7 @@ 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, effectiveRung, } from './ceiling.js';
-export type { Surface } from './ceiling.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 { renderOnReadDocs } from './on-read.js';
+export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read.js';

package/dist/core/substrate/index.js

@@ -19,7 +19,7 @@ resolveDocName, } from './schema.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, effectiveRung, } from './ceiling.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 { renderOnReadDocs } from './on-read.js';
+export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read.js';

package/dist/core/substrate/on-read.d.ts

@@ -1,14 +1,5 @@
-/**
- * Render the substrate docs that should surface alongside a just-read file.
- *
- * @param nodeId        the canvas node whose subject gates the docs.
- * @param readFilePath  the path the `read` tool returned (absolute or not — it
- *                      is resolved to a realpath internally).
- * @param seen          the CALLER-owned, per-session set of already-injected
- *                      doc realpaths. Docs already present are skipped; newly
- *                      injected docs are added. Pass the same set across reads
- *                      within a session (clear it on session_start) to get the
- *                      once-per-session dedup; omit it for a standalone render.
- * @returns the `<auto-loaded-context>` envelope, or '' when nothing surfaces.
- */
+/** Surface docs matched by a successful read tool call. */
 export declare function renderOnReadDocs(nodeId: string, readFilePath: string, seen?: Set<string>): string;
+/** Surface workspace-wide docs during first-message assembly. `.` is a reserved
+ * applies-to target meaning “when this project store is mounted by cwd/profile”. */
+export declare function renderWorkspaceOpenDocs(nodeId: string): string;