@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/keybindings/resolve.js

@@ -1,6 +1,6 @@
 import { isDeepStrictEqual } from 'node:util';
 import { BINDING_CATALOG, BINDING_IDS, SAFETY_REQUIREMENTS } from './catalog.js';
-import { readRawScopeConfig } from '../config.js';
+import { normalizeTmuxPassthrough, readRawScopeConfig } from '../config.js';
 const MODIFIER_ORDER = ['ctrl', 'alt', 'shift'];
 const INPUT_MODIFIERS = new Set(['ctrl', 'alt', 'shift', 'meta']);
 const NAMED_KEYS = new Set([
@@ -312,9 +312,16 @@ export function resolveKeybindings(rawOverrides = undefined) {
     };
     return Object.freeze(result);
 }
-export function resolveUserKeybindings() {
+/** Resolve keybindings and tmux passthrough from one immutable user-config snapshot. */
+export function resolveUserKeybindingSettings() {
     const raw = readRawScopeConfig('user');
-    return resolveKeybindings(raw?.keybindings);
+    return Object.freeze({
+        bindings: resolveKeybindings(raw?.keybindings),
+        tmuxPassthrough: Object.freeze(normalizeTmuxPassthrough(raw?.tmux_passthrough)),
+    });
+}
+export function resolveUserKeybindings() {
+    return resolveUserKeybindingSettings().bindings;
 }
 export function normalizeSparseOverrides(rawOverrides) {
     const resolved = resolveKeybindings(rawOverrides);

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

@@ -1,8 +1,7 @@
 // inline-ref-grammar.ts — the single source of truth for the inline
 // memory-reference token grammar (spec §4.1). Zero imports, pure string ops,
-// browser-safe: the broker, the terminal attach viewer, and the web composer
-// all import THIS module (directly, or via the browser barrel re-export in
-// `src/web/index.ts`) rather than each re-implementing `[A-Za-z0-9_:-]`,
+// browser-safe: the broker, terminal attach viewer, and web composer all import
+// this module directly rather than each re-implementing `[A-Za-z0-9_:-]`,
 // trimming, boundary detection, or `:` decoding. Divergence between the
 // viewer's highlight rule and the broker's resolution rule would let a
 // highlighted token yield no guidance (or vice versa) — see the spec and

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

@@ -1,16 +1,16 @@
 import { type InstalledPlugin, type Scope } from '../types.js';
 /**
- * Thin memory-document resolver for the document substrate. Precedence is the
- * OUTER loop, not a global scan: scopes/sources are tried NEAREST-FIRST
- * (node > project stack nearest > ... > profile > user > builtin), and WITHIN each
- * source, in order: (1) exact substrate-identity match (`doc.name === query`
- * — the explicit frontmatter `name`, or its path-derived fallback), (2) direct
- * `memory/<name>.md` physical-path lookup (plus the bare-dir/bare-plugin-name
- * → `INDEX.md` convenience neither identity nor a literal path expresses),
- * (3) bare leaf-name fallback (final path segment only). The first hit wins,
- * so a nearer source's match of ANY kind always beats a farther source's
- * match of any kind — a farther-scope identity can never shadow a
- * nearer-scope physical file. It returns the raw parsed frontmatter + body;
+ * Thin memory-document resolver for the document substrate. Resolution has
+ * two passes. First, scopes/sources are tried NEAREST-FIRST (node > project
+ * 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
+ * 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
+ * canonical identity. It returns the raw parsed frontmatter + body;
  * it does NOT interpret the schema, kind, gate, or rungs — that is the
  * schema/gate layer's job (callers filter by `frontmatter.kind`). Project
  * resolution is a nearest-first stack of every ancestor `.crouter/` (widened by
@@ -40,8 +40,8 @@ export interface MemoryDoc {
 /** The memory-only scope union: the global `Scope` (`user|project|builtin`)
  *  plus `profile` and `node`. Confined to the memory resolver/list/read/write/
  *  render paths — deliberately NOT folded into the global `Scope` union, because
- *  that would leak these into config, plugin, marketplace, view, and doctor/
- *  sys-config surfaces the spec does not extend. `node` is the this-node store
+ *  that would leak these into config, plugin, marketplace, and sys-config
+ *  surfaces the spec does not extend. `node` is the this-node store
  *  (`nodes/<id>/context/memory/`), available only inside a running node
  *  (`CRTR_NODE_ID`), and it is the NEAREST scope — a node doc overrides a
  *  same-named doc at any wider scope. */
@@ -90,22 +90,20 @@ export declare function listAllMemoryDocs(scope?: MemoryScope, quiet?: boolean):
  * `<name>` may carry topical subdirs (`taste/foo`); a bare leaf (`foo`) falls
  * back to a last-segment match within the resolved scopes.
  *
- * Precedence is the outer loop: sources are visited nearest-first, and the
- * FIRST source with any hit wins outright — a farther source is never even
- * consulted once a nearer one matches. Within each source, in order: (1)
- * exact substrate-identity match (`doc.name === query` — the explicit
- * frontmatter `name`, else its normalized path-derived fallback, the SAME
- * identity `listAllMemoryDocs` reports); (2) direct `memory/<name>.md`
- * physical-path lookup (the bare-dir → INDEX.md and bare-plugin-name → plugin
- * root INDEX.md conveniences neither identity nor a literal path expresses);
- * (3) bare leaf-name fallback (final path segment), ambiguous only when two
- * DIFFERENT identities in the SAME source share a leaf.
+ * Strong matches resolve before fallback matches. The first pass visits every
+ * source nearest-first and checks, within each source: (1) exact substrate
+ * identity (`doc.name === query` — the explicit frontmatter `name`, else its
+ * normalized path-derived fallback, the SAME identity `listAllMemoryDocs`
+ * reports); then (2) direct `memory/<name>.md` physical-path lookup (the
+ * bare-dir → INDEX.md and bare-plugin-name → plugin root INDEX.md conveniences
+ * neither identity nor a literal path expresses). Only if that pass finds
+ * nothing does a second nearest-first pass try bare leaf-name fallback (final
+ * path segment), ambiguous when two DIFFERENT identities in the SAME source
+ * share a leaf. A farther canonical identity therefore beats a nearer leaf,
+ * while scope precedence still decides between equally strong matches.
  *
- * `opts.kind`, when given, is a resolution CONSTRAINT, not a post-filter: at
- * each of the three steps above, a candidate whose `effectiveDocKind` doesn't
- * match is skipped rather than accepted, so a nearer source's wrong-kind doc
- * no longer shadows a farther source's matching-kind doc — resolution simply
- * keeps walking outward. A source only counts as having "an answer" once a
- * kind-matching candidate is found.
+ * `opts.kind`, when given, is a resolution CONSTRAINT, not a post-filter: in
+ * both passes a candidate whose `effectiveDocKind` doesn't match is skipped,
+ * so resolution keeps looking for a matching-kind document.
  */
 export declare function resolveMemoryDoc(rawName: string, opts?: MemoryResolutionOpts): MemoryDoc;

package/dist/core/memory-resolver.js

@@ -365,23 +365,21 @@ function formatLeafAmbiguous(leaf, matches) {
  * `<name>` may carry topical subdirs (`taste/foo`); a bare leaf (`foo`) falls
  * back to a last-segment match within the resolved scopes.
  *
- * Precedence is the outer loop: sources are visited nearest-first, and the
- * FIRST source with any hit wins outright — a farther source is never even
- * consulted once a nearer one matches. Within each source, in order: (1)
- * exact substrate-identity match (`doc.name === query` — the explicit
- * frontmatter `name`, else its normalized path-derived fallback, the SAME
- * identity `listAllMemoryDocs` reports); (2) direct `memory/<name>.md`
- * physical-path lookup (the bare-dir → INDEX.md and bare-plugin-name → plugin
- * root INDEX.md conveniences neither identity nor a literal path expresses);
- * (3) bare leaf-name fallback (final path segment), ambiguous only when two
- * DIFFERENT identities in the SAME source share a leaf.
+ * Strong matches resolve before fallback matches. The first pass visits every
+ * source nearest-first and checks, within each source: (1) exact substrate
+ * identity (`doc.name === query` — the explicit frontmatter `name`, else its
+ * normalized path-derived fallback, the SAME identity `listAllMemoryDocs`
+ * reports); then (2) direct `memory/<name>.md` physical-path lookup (the
+ * bare-dir → INDEX.md and bare-plugin-name → plugin root INDEX.md conveniences
+ * neither identity nor a literal path expresses). Only if that pass finds
+ * nothing does a second nearest-first pass try bare leaf-name fallback (final
+ * path segment), ambiguous when two DIFFERENT identities in the SAME source
+ * share a leaf. A farther canonical identity therefore beats a nearer leaf,
+ * while scope precedence still decides between equally strong matches.
  *
- * `opts.kind`, when given, is a resolution CONSTRAINT, not a post-filter: at
- * each of the three steps above, a candidate whose `effectiveDocKind` doesn't
- * match is skipped rather than accepted, so a nearer source's wrong-kind doc
- * no longer shadows a farther source's matching-kind doc — resolution simply
- * keeps walking outward. A source only counts as having "an answer" once a
- * kind-matching candidate is found.
+ * `opts.kind`, when given, is a resolution CONSTRAINT, not a post-filter: in
+ * both passes a candidate whose `effectiveDocKind` doesn't match is skipped,
+ * so resolution keeps looking for a matching-kind document.
  */
 export function resolveMemoryDoc(rawName, opts = {}) {
     const parsed = parseSkillQualifier(rawName);
@@ -394,36 +392,44 @@ export function resolveMemoryDoc(rawName, opts = {}) {
         throw usage(`memory document name required`);
     const segments = name.split('/');
     const isLeafQuery = !name.includes('/');
-    for (const source of memorySourcesInPrecedence(effectiveScope)) {
-        // Quiet: a targeted read must not spew other docs' frontmatter warnings
-        // before its own result (esp. a not_found) — corpus health is `lint`'s job.
-        const docs = sourceMemoryDocs(source, true);
-        const kindOk = (d) => opts.kind === undefined || effectiveDocKind(d) === opts.kind;
+    // Quiet: a targeted read must not spew other docs' frontmatter warnings
+    // before its own result (esp. a not_found) — corpus health is `lint`'s job.
+    const sources = memorySourcesInPrecedence(effectiveScope).map((source) => ({
+        source,
+        docs: sourceMemoryDocs(source, true),
+    }));
+    const kindOk = (d) => opts.kind === undefined || effectiveDocKind(d) === opts.kind;
+    // Strong matches across the full scope stack come first. This preserves
+    // nearest-scope shadowing for canonical/direct collisions without allowing a
+    // nested plugin template's leaf to hide a user doc whose full identity is the
+    // query.
+    for (const { source, docs } of sources) {
         const identity = docs.find((d) => d.name === name);
         if (identity && kindOk(identity))
             return identity;
         const direct = findMemoryMatchInSource(name, segments, source);
         if (direct && kindOk(direct))
             return direct;
-        if (isLeafQuery) {
+    }
+    if (isLeafQuery) {
+        for (const { docs } of sources) {
             const leafMatches = docs.filter((d) => (d.name.split('/').pop() ?? d.name) === name && kindOk(d));
-            if (leafMatches.length > 0) {
-                // Same path-derived name within this source → precedence wins (return
-                // first); genuinely different docs sharing a leaf → ambiguous. Either
-                // way this source has an answer — a farther source is never checked.
-                const distinctNames = new Set(leafMatches.map((d) => d.name));
-                if (distinctNames.size === 1)
-                    return leafMatches[0];
-                throw ambiguous(formatLeafAmbiguous(name, leafMatches), {
-                    memory: name,
-                    candidates: leafMatches.map((d) => ({
-                        id: memoryDocId(d),
-                        scope: d.scope,
-                        path: d.path,
-                    })),
-                    next: 'Multiple documents share this leaf name. Re-run with one of the full names in candidates.',
-                });
-            }
+            if (leafMatches.length === 0)
+                continue;
+            // Same path-derived name within this source → precedence wins (return
+            // first); genuinely different docs sharing a leaf → ambiguous.
+            const distinctNames = new Set(leafMatches.map((d) => d.name));
+            if (distinctNames.size === 1)
+                return leafMatches[0];
+            throw ambiguous(formatLeafAmbiguous(name, leafMatches), {
+                memory: name,
+                candidates: leafMatches.map((d) => ({
+                    id: memoryDocId(d),
+                    scope: d.scope,
+                    path: d.path,
+                })),
+                next: 'Multiple documents share this leaf name. Re-run with one of the full names in candidates.',
+            });
         }
     }
     throw notFound(`memory document not found: ${rawName}`, {

package/dist/core/model-routes.d.ts

@@ -1,4 +1,5 @@
 import type { ModelStrength } from '../types.js';
+import { type ProviderCandidate, type ProviderCandidateRejection } from './subscription-state.js';
 export type ModelRequest = {
     kind: 'logical';
     family: string;
@@ -30,8 +31,40 @@ export interface ModelRegistryLike {
     find(providerId: string, modelId: string): unknown;
     hasConfiguredAuth(model: unknown): boolean;
 }
+export interface InitialModelRegistryLike<Model extends {
+    provider: string;
+    id: string;
+}> {
+    find(providerId: string, modelId: string): Model | undefined;
+    getAll(): Model[];
+    hasConfiguredAuth(model: Model): boolean;
+}
+export interface InitialModelRouteSelection<Model extends {
+    provider: string;
+    id: string;
+}> {
+    selected?: {
+        model: Model;
+        candidate: ProviderCandidate;
+    };
+    rejected: Array<{
+        candidate: ProviderCandidate;
+        reason: ProviderCandidateRejection;
+    }>;
+}
 /** Expand config-derived route order only. Availability never affects rank. */
 export declare function expandModelCandidates(request: ModelRequest, cwd?: string, profileId?: string | null): RoutedCandidate[];
 /** Probe the common availability facts consumed unchanged by resolveProviderCandidates. */
 export declare function probeRouteAvailability(candidate: RoutedCandidate, registry: ModelRegistryLike, now?: number): RouteAvailability;
+/** Select the first viable route for a new SDK session. Route declarations own
+ * preference order; logical requests append registered models not declared by a
+ * route. The caller owns broker faults/events and the no-viable outcome. */
+export declare function selectInitialModelRoute<Model extends {
+    provider: string;
+    id: string;
+}>(request: ModelRequest, registry: InitialModelRegistryLike<Model>, options?: {
+    cwd?: string;
+    profileId?: string | null;
+    now?: number;
+}): InitialModelRouteSelection<Model>;
 export declare function modelRequestFromConfig(model: string | undefined, modelIntent: string | undefined, exact: boolean): ModelRequest | undefined;

package/dist/core/model-routes.js

@@ -1,5 +1,5 @@
 import { readMergedLaunchConfig } from './config.js';
-import { isManagedProvider, readRotationConfig, readSubscriptionPool } from './subscription-state.js';
+import { isManagedProvider, readRotationConfig, readSubscriptionPool, resolveProviderCandidates, } from './subscription-state.js';
 const STRENGTHS = ['ultra', 'strong', 'medium', 'light'];
 const THINKING_SUFFIXES = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
 function parseSpec(spec) {
@@ -55,8 +55,8 @@ export function expandModelCandidates(request, cwd, profileId) {
     const requestedStrength = logical?.strength ?? (() => {
         if (!concrete)
             return 'strong';
-        // Mirrors the former ladder back-map: preserve a precise thinking-level
-        // match, then map a drifting/omitted suffix to the weakest same-model cell.
+        // Preserve a precise thinking-level match, then map a drifting or omitted
+        // suffix to the weakest same-model cell.
         for (const exactThinking of [true, false]) {
             for (const strength of exactThinking ? STRENGTHS : [...STRENGTHS].reverse()) {
                 if (routeEntries.some(([, route]) => {
@@ -125,6 +125,45 @@ export function probeRouteAvailability(candidate, registry, now = Date.now()) {
         ...(cooling ? { coolingUntil: Math.min(...pool.map((entry) => entry.rateLimitedUntil || 0)) } : {}),
     };
 }
+/** Select the first viable route for a new SDK session. Route declarations own
+ * preference order; logical requests append registered models not declared by a
+ * route. The caller owns broker faults/events and the no-viable outcome. */
+export function selectInitialModelRoute(request, registry, options = {}) {
+    const routes = expandModelCandidates(request, options.cwd, options.profileId);
+    const routeKeys = new Set(routes.map((candidate) => `${candidate.providerId}/${candidate.modelId}`));
+    const tail = request.kind === 'logical'
+        ? registry.getAll()
+            .filter((model) => !routeKeys.has(`${model.provider}/${model.id}`))
+            .map((model, index) => ({
+            routeId: `registry:${model.provider}/${model.id}`,
+            credentialSource: 'registry',
+            family: model.provider,
+            strength: 'strong',
+            providerId: model.provider,
+            modelId: model.id,
+            rank: routes.length + index,
+        }))
+        : [];
+    const candidates = [...routes, ...tail];
+    const now = options.now ?? Date.now();
+    const hasManagedAuthenticated = candidates.some((candidate) => {
+        const availability = probeRouteAvailability(candidate, registry, now);
+        return isManagedProvider(candidate.providerId) && availability.registered && availability.authenticated;
+    });
+    const selection = resolveProviderCandidates(candidates.map((candidate) => ({
+        ...candidate,
+        ...probeRouteAvailability(candidate, registry, now),
+        automaticFallback: candidate.routeId.startsWith('registry:')
+            ? (isManagedProvider(candidate.providerId) || !hasManagedAuthenticated)
+            : true,
+    })), now, { pinnedToFirst: request.kind === 'exact' });
+    const candidate = selection.candidates[0];
+    const model = candidate === undefined ? undefined : registry.find(candidate.providerId, candidate.modelId);
+    return {
+        ...(candidate !== undefined && model !== undefined ? { selected: { model, candidate } } : {}),
+        rejected: selection.rejected,
+    };
+}
 export function modelRequestFromConfig(model, modelIntent, exact) {
     if (!model)
         return undefined;

package/dist/core/preview-registry.js

@@ -156,12 +156,7 @@ const LEAF_ICON_CP = {
     'search web': 0xf0ac,
     'search answer': 0xf075,
     'search contents': 0xf0f6,
-    'surface view list': 0xf03a,
-    'surface view run': 0xf04b,
-    'surface view cycle': 0xf021,
-    'surface view new': 0xf067,
     'surface attach to': 0xf1e6,
-    'surface workspace enter': 0xf120,
     'surface web serve': 0xf0ac,
     'sys config get': 0xf019,
     'sys config set': 0xf040,
@@ -170,7 +165,6 @@ const LEAF_ICON_CP = {
     'sys doctor': 0xf0f1,
     'sys sysprompt': 0xf15c,
     'sys prompt-review': 0xf002,
-    'sys promptstudio': 0xf008,
     'sys feedback': 0xf075,
     'sys update': 0xf021,
     'sys version': 0xf02b,
@@ -1326,22 +1320,23 @@ function summarizeHumanAsk(text, tokens) {
     }
     return lines;
 }
-/** `crtr human review` (humanReview.run, src/commands/human/prompts.ts)
- *  returns `{job_id, dir, output, follow_up}` — same recognition strategy as
- *  summarizeHumanAsk (job_id bullet + the stable `Queued for the human`
- *  road-sign prefix, which review shares with ask). The
- *  reviewed file isn't in the output either, so its basename is recovered
- *  from argv (the file positional, skipping `--output`'s value). Returns null
- *  when the road-sign is absent. */
-function summarizeHumanReview(text, tokens) {
-    const jobId = /^- job_id:\s*(\S+)\s*$/m.exec(text)?.[1];
-    if (jobId === undefined)
-        return null;
-    if (!text.includes('Queued for the human'))
-        return null;
-    const file = firstPositionalArg(tokens, 2, new Set(['--output']));
+/** `crtr human review new` (humanReviewNew.run,
+ *  src/commands/human/review.ts) returns `{job_id, dir, output, review_id,
+ *  follow_up}`. A ticket bridge id plus the daemon-owned review id and the
+ *  stable live-review road-sign distinguish this canonical result from an
+ *  error or another review leaf. The reviewed file is recovered from argv:
+ *  it is the positional after `human review new`, skipping the two value
+ *  flags. Returns null when that canonical result shape is absent. */
+function summarizeHumanReviewNew(text, tokens) {
+    const jobId = readFieldFlexible(text, 'job_id');
+    const reviewId = readFieldFlexible(text, 'review_id');
+    if (jobId === undefined || reviewId === undefined)
+        return null;
+    if (!text.includes('The review is live for the person in the attach viewer with its companion agent.'))
+        return null;
+    const file = firstPositionalArg(tokens, 3, new Set(['--output', '--subtitle']));
     const label = file !== undefined ? `review posted: ${basename(file)}` : 'review posted';
-    return [{ text: `${label} → waiting on human`, tone: 'accent' }];
+    return [{ text: `${label} → live with companion`, tone: 'accent' }];
 }
 /** `crtr human list` (humanList.run, src/commands/human/queue.ts:283) has no
  *  custom `render`; the generic renderer bullets `- total: N` then an
@@ -2647,38 +2642,6 @@ function summarizeSysSupportSubmit(text) {
         { text: url, tone: 'muted' },
     ];
 }
-const SURFACE_VIEW_LIST_ID_CAP = 8;
-/** `crtr surface view list` (viewListLeaf.render, src/commands/view-list.ts:
- *  59) has a custom render, NOT the generic renderResult: one padded plain
- *  line per view, `<id padded>  <title padded>  [<scope>]<optional
- *  desc/error>` (verified live, 2026-07-01) — no GFM table markup at all, so
- *  this file's shared parseTableRows/splitTableRow helpers don't apply.
- *  Real ids/titles never contain a run of 2+ spaces, so each real field
- *  boundary (the column padding plus the literal `  ` separator together
- *  always total 2+ spaces) is recoverable by anchoring on the `[scope]`
- *  bracket. Returns null when the roster is empty (`No views found…`, a
- *  single plain line the generic path already renders fine) or any line
- *  fails to match this row shape — including the pi truncation marker,
- *  which never contains a `[scope]` bracket or a 2+-space run. */
-function summarizeSurfaceViewList(text) {
-    const lines = text.split('\n').filter((l) => l.trim() !== '');
-    if (lines.length === 0)
-        return null;
-    const ids = [];
-    for (const line of lines) {
-        const m = /^(\S+)\s{2,}.+?\s{2,}\[\w[\w-]*\](?:\s{2,}.*)?$/.exec(line);
-        if (m === null)
-            return null;
-        ids.push(m[1]);
-    }
-    const shown = ids.slice(0, SURFACE_VIEW_LIST_ID_CAP);
-    const remaining = ids.length - shown.length;
-    const idsLine = remaining > 0 ? `${shown.join(', ')}, … ${remaining} more` : shown.join(', ');
-    return [
-        { text: `${ids.length} views` },
-        { text: idsLine, tone: 'muted' },
-    ];
-}
 /** Focus is the high-frequency generic surface result. The target is an argv
  * asset because the result does not echo it; all three booleans are required
  * so a partial/error result never becomes a false success receipt. */
@@ -2746,7 +2709,7 @@ const SUMMARIZERS = [
     { path: 'push urgent', run: summarizePushUrgent },
     { path: 'push final', run: summarizePushFinal },
     { path: 'human ask', run: summarizeHumanAsk },
-    { path: 'human review', run: summarizeHumanReview },
+    { path: 'human review new', run: summarizeHumanReviewNew },
     { path: 'human list', run: summarizeHumanList },
     { path: 'human deck', run: summarizeHumanDeck },
     { path: 'human notify', run: summarizeHumanNotify },
@@ -2798,7 +2761,6 @@ const SUMMARIZERS = [
     { path: 'sys logs', run: summarizeSysLogs },
     { path: 'sys support prepare', run: summarizeSysSupportPrepare },
     { path: 'sys support submit', run: summarizeSysSupportSubmit },
-    { path: 'surface view list', run: summarizeSurfaceViewList },
     { path: 'surface node focus', run: summarizeSurfaceNodeFocus },
     { path: 'surface edit', run: summarizeSurfaceEdit },
 ];

package/dist/core/profiles/select.js

@@ -297,9 +297,9 @@ function rootProfileMessage(cwd) {
  *  the session IS interactive. Ask on the controlling terminal — create a
  *  profile pointing at cwd, or proceed as root — and block until answered.
  *  Deliberately a minimal `readline` prompt, not `crtr human ask`: that bridge
- *  is asynchronous (registers an interaction with humanloop, then waits for the
- *  human to answer it from a separate inbox) and cannot gate pi's boot; the
- *  humanloop entry points (`human ask`/`review`) are built for a queued,
+ *  is asynchronous (registers an interaction in the ticket store, then waits for
+ *  the human to answer it from a separate inbox) and cannot gate pi's boot; those
+ *  entry points (`human ask`/`review`) are built for a queued,
  *  asynchronously-answered interaction, not a two-choice gate on the same TTY pi
  *  is about to take over — a raw `readline` question is the actual minimal
  *  fit here. */

package/dist/core/{view/remote-canvas-target.d.ts → remote-canvas-target.d.ts}

@@ -1,4 +1,4 @@
-import type { Scope, RemoteCanvasTarget } from '../../types.js';
-import type { RelayTarget } from '../broker-client/index.js';
+import type { Scope, RemoteCanvasTarget } from '../types.js';
+import type { RelayTarget } from './broker-client/index.js';
 export declare function getRemoteCanvasTarget(name: string, scope?: Scope): RemoteCanvasTarget | undefined;
 export declare function resolveRemoteCanvasTarget(name: string, scope?: Scope): RelayTarget;

package/dist/core/{view/remote-canvas-target.js → remote-canvas-target.js}

@@ -1,4 +1,4 @@
-// remote-canvas-target.ts — resolves a named `remoteCanvas.targets.<name>`
+// remote-target.ts — resolves a named `remoteCanvas.targets.<name>`
 // config entry (see `RemoteCanvasTarget`, `src/types.ts`) into a `RelayTarget`
 // ready for `RelayTransport` (`src/core/broker-client/transport-relay.ts`).
 //
@@ -7,9 +7,9 @@
 // resolved here at connect time via `getRelayToken`. Targets are registered
 // and the token stored via `crtr canvas config add` (`--relay-token -` reads
 // it from stdin, the preferred form to keep it out of shell history).
-import { usage } from '../errors.js';
-import { readConfig } from '../config.js';
-import { getRelayToken } from '../secrets.js';
+import { usage } from './errors.js';
+import { readConfig } from './config.js';
+import { getRelayToken } from './secrets.js';
 export function getRemoteCanvasTarget(name, scope = 'user') {
     return readConfig(scope).remoteCanvas.targets[name];
 }

package/dist/core/review/__tests__/capture-origin.test.d.ts

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