@north-light/crouter 0.3.262 → 0.3.269

package/dist/commands/sys/context/admin/model.js

@@ -4,6 +4,7 @@
 import { resolve as resolvePath } from 'node:path';
 import { realpathOrSelf } from '../../../../core/fs-utils.js';
 import { planDelivery, } from '../../../../core/substrate/plan.js';
+import { assembleEventAccounting, effectivePlan, } from '../resolve.js';
 import { RUNGS, SURFACE_EVENTS, previewLine, rungRank, } from '../../../../core/substrate/schema.js';
 import { scopeForCwd, profileNameFor } from '../../../../core/substrate/subject-fields.js';
 import { resolveMemoryDocForTarget } from '../../../../core/memory-resolver.js';
@@ -71,7 +72,12 @@ export class PlanSet {
         const held = this.plans.get(event);
         if (held !== undefined)
             return held;
-        const computed = planDelivery(subjectOf(this.snapshot), targetOf(this.snapshot), event, this.payload(event));
+        const subject = subjectOf(this.snapshot);
+        const target = targetOf(this.snapshot);
+        const payload = this.payload(event);
+        const direct = planDelivery(subject, target, event, payload);
+        const rendered = assembleEventAccounting({ subject, target, nodeMissing: false }, event, payload);
+        const computed = effectivePlan(direct, rendered.accounting.deliveries, payload);
         this.plans.set(event, computed);
         return computed;
     }

package/dist/commands/sys/context/admin/read-view.d.ts

@@ -1,5 +1,5 @@
 import { type Rung, type SurfaceEvent } from '../../../../core/substrate/schema.js';
-import type { DeliveryRecord } from '../../../../core/substrate/plan.js';
+import type { EffectiveDeliveryRecord } from '../resolve.js';
 import type { NodeConfigSubject } from '../../../../core/substrate/subject-fields.js';
 /** The profile project entry whose `memory` rung ceilings this document's
  *  store, or null when no project governs it. */
@@ -11,7 +11,7 @@ export interface CapOwner {
  *  the sibling events' records, and the two facts the shell resolves. */
 export interface DossierContext {
     event: SurfaceEvent;
-    records: Map<SurfaceEvent, DeliveryRecord>;
+    records: Map<SurfaceEvent, EffectiveDeliveryRecord>;
     capOwner: CapOwner | null;
     readOnly: boolean;
     /** The configuration every record here was planned against — what a failed
@@ -20,12 +20,12 @@ export interface DossierContext {
 }
 /** The resting card, and — when `bodyOpen` — the document's own text beneath
  *  it in place of the affordance line that names it. */
-export declare function renderDossierRead(record: DeliveryRecord, context: DossierContext, width: number, bodyOpen: boolean): string[];
+export declare function renderDossierRead(record: EffectiveDeliveryRecord, context: DossierContext, width: number, bodyOpen: boolean): string[];
 /** Identity and routing — what the edit face keeps overhead of its field list,
  *  because they are the context a field is being edited against. */
-export declare function renderDossierHeader(record: DeliveryRecord, context: DossierContext, width: number): string[];
+export declare function renderDossierHeader(record: EffectiveDeliveryRecord, context: DossierContext, width: number): string[];
 /** Does it load here, what does it cost, and — only when there is one — what
  *  interfered. The three questions the old verdict, cost table and event grid
  *  each answered a piece of. */
-export declare function renderDossierDelivery(record: DeliveryRecord, context: DossierContext, width: number): string[];
+export declare function renderDossierDelivery(record: EffectiveDeliveryRecord, context: DossierContext, width: number): string[];
 export declare function bodyLineCount(body: string): number;

package/dist/commands/sys/context/admin/read-view.js

@@ -25,11 +25,13 @@ const INDENT = ' ';
 export function renderDossierRead(record, context, width, bodyOpen) {
     const inner = Math.max(1, width - INDENT.length);
     const out = renderDossierHeader(record, context, width);
-    if (record.doc.shortForm.trim() !== '') {
-        out.push('');
-        out.push(...indent(wrapped(record.doc.shortForm, inner)));
-    }
     out.push(...renderDossierDelivery(record, context, width));
+    // The gist sits against the body it summarizes: last of the card, directly
+    // above the affordance that opens the text it stands in for.
+    const gist = record.doc.shortForm.trim();
+    if (gist !== '') {
+        out.push('', theme.fg('dim', `${INDENT}SHORT FORM`), ...indent(wrapped(gist, inner)));
+    }
     const lines = bodyLineCount(record.doc.body);
     if (bodyOpen) {
         out.push('');
@@ -139,6 +141,9 @@ export function renderDossierDelivery(record, context, width) {
             ? `capped to ${record.cappedRung} by a profile ceiling on this store`
             : `capped to ${record.cappedRung} by the ${context.capOwner.memory} ceiling on ${context.capOwner.path}`);
     }
+    if (record.deliveryCause !== undefined) {
+        out.push(...dim(record.deliveryCause, width));
+    }
     if (record.shadowedBy !== null) {
         out.push(...indent(wrapped(`shadowed by the ${record.shadowedBy.scope} copy at ${record.shadowedBy.path}`, inner)).map((line) => theme.fg('muted', line)));
     }

package/dist/commands/sys/context/resolve.d.ts

@@ -1,6 +1,7 @@
-import { type MemoryTarget } from '../../../core/memory-resolver.js';
-import { type DeliveryPayload, type DeliveryRecord, type GateOutcome } from '../../../core/substrate/plan.js';
+import { type MemoryDoc, type MemoryTarget } from '../../../core/memory-resolver.js';
+import { type DeliveryPayload, type DeliveryPlan, type DeliveryRecord, type GateOutcome } from '../../../core/substrate/plan.js';
 import { type GateClause } from '../../../core/substrate/gate-explain.js';
+import { deliveryAccounting } from '../../../core/substrate/on-read.js';
 import { type Rung, type SurfaceEntry, type SurfaceEvent } from '../../../core/substrate/schema.js';
 import { type NodeConfigSubject } from '../../../core/substrate/subject-fields.js';
 export declare const resolveLeaf: import("../../../core/command.js").LeafDef;
@@ -26,6 +27,10 @@ export interface PayloadFlags {
 export declare function payloadFor(event: SurfaceEvent, flags: PayloadFlags, target: MemoryTarget): DeliveryPayload;
 export declare function subjectSummary(subject: NodeConfigSubject): Record<string, unknown>;
 export declare function optionalString(value: unknown): string | null;
+export interface EffectiveDeliveryRecord extends DeliveryRecord {
+    /** Present when the renderer raised this doc beyond its direct event plan. */
+    deliveryCause?: string;
+}
 export interface DocRow {
     name: string;
     kind: string;
@@ -40,13 +45,24 @@ export interface DocRow {
     doc_gate: string;
     entry_gate: string | null;
     matched_entry: string | null;
+    delivery_cause?: string;
     excluded?: string;
 }
+/** Overlay the production renderer's actual document deliveries onto direct
+ * planner records. The plan still supplies gates, caps, and exclusion detail;
+ * only an attachment that genuinely rendered may raise its final rung. */
+export declare function effectivePlan(plan: DeliveryPlan, deliveries: ReadonlyMap<string, {
+    rung: Rung;
+    cause?: string;
+    source?: MemoryDoc;
+}>, payload?: DeliveryPayload): DeliveryPlan & {
+    docs: EffectiveDeliveryRecord[];
+};
 /** A document delivers when it won its canonical name AND resolved to a rung
  *  above the no-delivery floor — boot keeps rung-`none` winners in the plan so
  *  the catalog can still count them. */
 export declare function delivers(record: DeliveryRecord): boolean;
-export declare function docRow(record: DeliveryRecord, includeAll: boolean, subject: NodeConfigSubject | null): DocRow;
+export declare function docRow(record: EffectiveDeliveryRecord, includeAll: boolean, subject: NodeConfigSubject | null): DocRow;
 /** A gate verdict as one cell: `pass`, or `fail:` plus the clauses that failed
  *  — the planner's generic sentence only when the explainer cannot decompose
  *  the predicate. */
@@ -55,5 +71,18 @@ export declare function entryText(entry: SurfaceEntry | null): string | null;
 /** Why a considered document delivers nothing, in the order the planner applies
  *  its checks — the first failing one is the answer an engineer acts on. */
 export declare function exclusionReason(record: DeliveryRecord, subject: NodeConfigSubject | null): string;
+/** Every renderer resolves its corpus from the AMBIENT process (cwd plus the
+ *  two env seams), not from a target argument, so a snapshot dialed away from
+ *  this process is only honored by standing in its place for the call. The
+ *  session parse cache is cleared on both sides so neither the emulated corpus
+ *  nor the real one is served from the other's scan. */
+export interface AccountedEventRender {
+    assembled: string;
+    accounting: ReturnType<typeof deliveryAccounting>;
+}
+/** Run the production renderer once and retain the structured document
+ * deliveries it recorded. Context diagnostics and the admin viewer consume
+ * this result rather than reconstructing attachment/companion fixpoints. */
+export declare function assembleEventAccounting(snapshot: ContextSnapshot, event: SurfaceEvent, payload: DeliveryPayload): AccountedEventRender;
 export declare function describeSubject(subject: Record<string, unknown>): string;
 export declare function cell(v: unknown): string;

package/dist/commands/sys/context/resolve.js

@@ -19,9 +19,9 @@ import { planDelivery, } from '../../../core/substrate/plan.js';
 import { explainRecordGate, formatClause } from '../../../core/substrate/gate-explain.js';
 import { emptyContextExposureState, exposureTarget } from '../../../core/substrate/injected-store.js';
 import { renderPreferencesForSubject, renderKnowledgeForSubject } from '../../../core/substrate/render.js';
-import { memoryReadDocBlocks, renderOnCommandDocsForSubject, renderOnReadDocsForSubject, renderPreCommandDocsForSubject, renderWorkspaceOpenDocsForSubject, } from '../../../core/substrate/on-read.js';
+import { deliveryAccounting, memoryReadDocBlocks, renderOnCommandDocsForSubject, renderOnReadDocsForSubject, renderPreCommandDocsForSubject, renderWorkspaceOpenDocsForSubject, } from '../../../core/substrate/on-read.js';
 import { clearSessionCache } from '../../../core/substrate/session-cache.js';
-import { rungAtLeast, SURFACE_EVENTS, } from '../../../core/substrate/schema.js';
+import { parseSubstrateDoc, rungAtLeast, SURFACE_EVENTS, } from '../../../core/substrate/schema.js';
 import { scopeForCwd, profileNameFor } from '../../../core/substrate/subject-fields.js';
 import { resetScopeCache } from '../../../core/scope.js';
 import { getDefaultProfileId } from '../../../core/profiles/default-binding.js';
@@ -52,7 +52,7 @@ export const resolveLeaf = defineLeaf({
             { name: 'event', type: 'string', required: false, constraint: 'The resolved event. Absent with --all-events, where every entry in `plans` carries its own.' },
             { name: 'subject', type: 'object', required: true, constraint: 'The configuration snapshot used: kind, mode, lifecycle, hasManager, profile, scope.' },
             { name: 'target', type: 'object', required: true, constraint: 'Store resolution inputs: cwd, profileId, nodeId.' },
-            { name: 'docs', type: 'array', required: false, constraint: 'One entry per document, at `docs`/`all` granularity: name, kind, scope, store_path, authored_rung, project_memory_cap, capped_rung, final_rung, winner, shadowed_by, doc_gate, entry_gate, matched_entry, and excluded when --all includes a non-delivering document.' },
+            { name: 'docs', type: 'array', required: false, constraint: 'One entry per document, at `docs`/`all` granularity: name, kind, scope, store_path, authored_rung, project_memory_cap, capped_rung, final_rung, winner, shadowed_by, doc_gate, entry_gate, matched_entry, delivery_cause when the renderer raised it through a content attachment, and excluded when --all includes a non-delivering document.' },
             { name: 'counts', type: 'object', required: false, constraint: 'At `summary` granularity: {considered, delivered: {content, preview, name}, delivered_total, excluded: {<reason>: count}}.' },
             { name: 'all_ignored', type: 'boolean', required: false, constraint: 'Present only when --all is supplied with --granularity assembled; true means assembled text is unchanged because --all applies only to docs granularity.' },
             { name: 'assembled', type: 'string', required: false, constraint: 'At `assembled` granularity: the exact text the node would receive for this event.' },
@@ -188,15 +188,59 @@ async function fetchSubjectOrNull(nodeId) {
     }
 }
 function planSection(snapshot, event, payload, granularity, includeAll) {
-    if (granularity === 'assembled') {
-        return { event, assembled: assembleEvent(snapshot, event, payload) };
-    }
-    const plan = planDelivery(snapshot.subject, snapshot.target, event, payload);
+    const rendered = assembleEventAccounting(snapshot, event, payload);
+    if (granularity === 'assembled')
+        return { event, assembled: rendered.assembled };
+    const plan = effectivePlan(planDelivery(snapshot.subject, snapshot.target, event, payload), rendered.accounting.deliveries, payload);
     if (granularity === 'summary')
         return { event, counts: countsOf(plan) };
     const docs = plan.docs.filter((r) => includeAll || delivers(r)).map((r) => docRow(r, includeAll, plan.subject));
     return { event, docs };
 }
+/** Overlay the production renderer's actual document deliveries onto direct
+ * planner records. The plan still supplies gates, caps, and exclusion detail;
+ * only an attachment that genuinely rendered may raise its final rung. */
+export function effectivePlan(plan, deliveries, payload = {}) {
+    const seen = new Set();
+    const docs = plan.docs.map((record) => {
+        seen.add(realpathOrSelf(record.doc.path));
+        const delivered = deliveries.get(realpathOrSelf(record.doc.path));
+        if (delivered === undefined || !rungAtLeast(delivered.rung, record.finalRung))
+            return record;
+        const raised = delivered.rung !== record.finalRung;
+        return {
+            ...record,
+            // A companion has its own memory-read winner set. If it is shadowed or
+            // silent in the outer event plan but genuinely rendered through that
+            // attachment, the rendered delivery is the truth this view reports.
+            ...(raised ? { winner: true, shadowedBy: null } : {}),
+            finalRung: delivered.rung,
+            ...(raised && delivered.cause !== undefined ? { deliveryCause: delivered.cause } : {}),
+        };
+    });
+    for (const delivered of deliveries.values()) {
+        if (delivered.source === undefined || seen.has(realpathOrSelf(delivered.source.path)))
+            continue;
+        const doc = parseSubstrateDoc(delivered.source);
+        if (doc === null)
+            continue;
+        // Workspace-open deliberately plans only project stores, while its real
+        // listing/companion attachments answer from the full target view. Plan this
+        // one rendered source solely to retain normal dossier metadata, then make
+        // its renderer-recorded rung and cause authoritative.
+        const record = planDelivery(plan.subject, plan.target, plan.event, payload, [{ doc, source: delivered.source }]).docs[0];
+        if (record === undefined)
+            continue;
+        docs.push({
+            ...record,
+            winner: true,
+            shadowedBy: null,
+            finalRung: delivered.rung,
+            ...(delivered.cause === undefined ? {} : { deliveryCause: delivered.cause }),
+        });
+    }
+    return { ...plan, docs };
+}
 /** A document delivers when it won its canonical name AND resolved to a rung
  *  above the no-delivery floor — boot keeps rung-`none` winners in the plan so
  *  the catalog can still count them. */
@@ -218,6 +262,7 @@ export function docRow(record, includeAll, subject) {
         doc_gate: gateText(record.docGate, explainRecordGate(record, 'doc', subject)),
         entry_gate: record.entryGate === null ? null : gateText(record.entryGate, explainRecordGate(record, 'entry', subject)),
         matched_entry: entryText(record.matchedEntry),
+        ...(record.deliveryCause === undefined ? {} : { delivery_cause: record.deliveryCause }),
     };
     if (includeAll && !delivers(record))
         row.excluded = exclusionReason(record, subject);
@@ -294,26 +339,23 @@ function exclusionBucket(record) {
     }
     return record.cappedRung === 'none' ? 'capped' : 'rung_none';
 }
-// Assembled granularity — the real renderers, so the highest-fidelity view is
-// byte-identical to what the node receives.
-/** Every renderer resolves its corpus from the AMBIENT process (cwd plus the
- *  two env seams), not from a target argument, so a snapshot dialed away from
- *  this process is only honored by standing in its place for the call. The
- *  session parse cache is cleared on both sides so neither the emulated corpus
- *  nor the real one is served from the other's scan. */
-function assembleEvent(snapshot, event, payload) {
+/** Run the production renderer once and retain the structured document
+ * deliveries it recorded. Context diagnostics and the admin viewer consume
+ * this result rather than reconstructing attachment/companion fixpoints. */
+export function assembleEventAccounting(snapshot, event, payload) {
     const restore = {
         cwd: process.cwd(),
         profileId: envProfileId(),
         nodeId: envNodeId(),
     };
+    const accounting = deliveryAccounting();
     clearSessionCache();
     resetScopeCache();
     try {
         process.chdir(snapshot.target.cwd);
         setEnv('CRTR_PROFILE_ID', snapshot.target.profileId ?? undefined);
         setEnv('CRTR_NODE_ID', snapshot.target.nodeId ?? undefined);
-        return renderEvent(snapshot, event, payload);
+        return { assembled: renderEvent(snapshot, event, payload, accounting), accounting };
     }
     finally {
         process.chdir(restore.cwd);
@@ -329,29 +371,34 @@ function setEnv(name, value) {
     else
         process.env[name] = value;
 }
-function renderEvent(snapshot, event, payload) {
+function renderEvent(snapshot, event, payload, accounting) {
     const { subject, target } = snapshot;
     switch (event) {
         case 'boot': {
-            const { block } = renderPreferencesForSubject(subject);
-            const knowledge = target.nodeId === null ? '' : renderKnowledgeForSubject(subject, target.nodeId);
+            const { block } = renderPreferencesForSubject(subject, undefined, accounting);
+            const knowledge = target.nodeId === null ? '' : renderKnowledgeForSubject(subject, target.nodeId, undefined, accounting);
             return knowledge === '' ? block : `${block}\n\n${knowledge}`;
         }
         case 'workspace-open':
-            return renderWorkspaceOpenDocsForSubject(subject, target.cwd, target.profileId);
+            return renderWorkspaceOpenDocsForSubject(subject, target.cwd, target.profileId, undefined, accounting);
         case 'read':
-            return payload.absoluteFile === undefined ? '' : renderOnReadDocsForSubject(subject, payload.absoluteFile);
+            return payload.absoluteFile === undefined ? '' : renderOnReadDocsForSubject(subject, payload.absoluteFile, undefined, accounting);
         case 'memory-read': {
             const name = payload.resolvedCanonicalName;
             if (name === undefined)
                 return '';
-            const blocks = memoryReadDocBlocks(subject, payload.resolvedDocPath ?? '', name, exposureTarget(emptyContextExposureState(), 'transcript'));
+            const blocks = memoryReadDocBlocks(payload.resolvedDocPath ?? '', name, {
+                subject,
+                target: exposureTarget(emptyContextExposureState(), 'transcript'),
+                listings: 'blocks',
+                accounting,
+            });
             return blocks.length === 0 ? '' : `<auto-loaded-context>\n${blocks.join('\n')}\n</auto-loaded-context>`;
         }
         case 'command':
-            return payload.command === undefined ? '' : renderOnCommandDocsForSubject(subject, payload.command);
+            return payload.command === undefined ? '' : renderOnCommandDocsForSubject(subject, payload.command, undefined, accounting);
         case 'pre-command':
-            return payload.command === undefined ? '' : renderPreCommandDocsForSubject(subject, payload.command);
+            return payload.command === undefined ? '' : renderPreCommandDocsForSubject(subject, payload.command, undefined, accounting);
     }
 }
 /** The read document never delivers to itself, so the plan needs its physical
@@ -403,7 +450,8 @@ function renderSection(section) {
     if (docs.length === 0)
         return 'No document delivers for this event.';
     const showExcluded = docs.some((d) => d.excluded !== undefined);
-    const cols = ['document', 'scope', 'kind', 'authored', 'cap', 'final', 'matched', 'gate', ...(showExcluded ? ['excluded'] : [])];
+    const showCause = docs.some((d) => d.delivery_cause !== undefined);
+    const cols = ['document', 'scope', 'kind', 'authored', 'cap', 'final', 'matched', 'gate', ...(showCause ? ['cause'] : []), ...(showExcluded ? ['excluded'] : [])];
     const rows = docs.map((d) => [
         d.name,
         d.scope,
@@ -413,6 +461,7 @@ function renderSection(section) {
         d.final_rung,
         d.matched_entry ?? '—',
         d.doc_gate,
+        ...(showCause ? [d.delivery_cause ?? ''] : []),
         ...(showExcluded ? [d.excluded ?? ''] : []),
     ]);
     return [

package/dist/commands/sys/panels/models-panel.d.ts

@@ -10,6 +10,8 @@ export declare class ModelsPanel implements SetupPanel {
     private readonly label;
     private mode;
     private ladders;
+    private modelRoutes;
+    private legacyModelRoutes;
     private kinds;
     /** The ladder providers this panel offers — only columns whose runtime
      *  provider is signed in (all of them when nobody is, so config stays
@@ -27,8 +29,11 @@ export declare class ModelsPanel implements SetupPanel {
     private modelSelector;
     private thinkingSelector;
     private pending;
-    private pendingDim;
-    private dimPickIndex;
+    private choice;
+    private choiceIndex;
+    private routeForm;
+    private readonly routeInput;
+    private pendingRouteCell;
     onChange?: () => void;
     constructor(tui: TUI, runtime: ModelRuntime, registry: ModelRegistry, matches: (id: BindingId, data: string) => boolean, label: (id: BindingId) => string);
     /** Same signed-in rule as the broker's Alt+M cycle: pool occupancy for a
@@ -38,6 +43,8 @@ export declare class ModelsPanel implements SetupPanel {
     private cycleTarget;
     private shadowingPath;
     private savedButShadowed;
+    private routeIds;
+    private routeFamilies;
     private buildRows;
     private reload;
     /** Re-read config and auth state — called when the Models tab is entered so
@@ -50,12 +57,26 @@ export declare class ModelsPanel implements SetupPanel {
     private clampColumn;
     handleInput(data: string): boolean;
     private activateCell;
-    /** Snapshot of the mode's current provider+strength. For orchestrator this
+    private portableSelection;
+    private familyLabel;
+    private familyOptions;
+    /** Snapshot of the mode's current family+strength. For orchestrator this
      *  falls back to the base `model` when no explicit override exists, so the
      *  inherited pair is what an edit preserves. */
     private kindSelection;
     private openDimensionPicker;
-    private commitDimensionPick;
+    private writeKindSelection;
+    private commitChoice;
+    private openRouteForm;
+    private closeRouteForm;
+    private activateRouteField;
+    private setRouteProvider;
+    private openRouteCell;
+    private onRouteModelPicked;
+    private saveRoute;
+    private declaringPath;
+    private deleteRoute;
+    private showModelSelector;
     private openModelPicker;
     private onModelPicked;
     private onThinkingPicked;
@@ -66,7 +87,9 @@ export declare class ModelsPanel implements SetupPanel {
     private targetKindOverride;
     footerHint(): string;
     /** Body lines only — the caller frames and windows them. */
-    private renderDimensionPicker;
+    private renderChoicePicker;
+    private renderRouteForm;
+    private renderRouteDelete;
     /** Fits the panel body into `budget` rows. The wizard draws header/tabs above
      *  and a footer below, so a body taller than its budget pushes the tab strip
      *  off the top of the terminal — the panel must window itself instead. Chrome