@north-light/crouter 0.3.179 → 0.3.181

package/dist/api/client.d.ts

@@ -5,16 +5,17 @@ import type { PushReportRequest, PushReportResultDTO, ReportDTO, ReportsQuery }
 import type { CloseRequest, CloseResultDTO, PromoteRequest, RelaunchRootResultDTO, ReviveRequest, ReviveResultDTO, WaitRequest, YieldRequest } from './dto/lifecycle.js';
 import type { SubscribeRequest, SubscriptionDTO } from './dto/subscriptions.js';
 import type { FocusDTO, RegisterFocusRequest, SetFocusPaneRequest } from './dto/focus.js';
-import { type ArmCronRequest, type CancelCronQuery, type CronDTO, type CronRunDTO, type CronScopeQuery, type CronShowDTO, type ListCronsQuery } from './dto/crons.js';
+import { type ArmCronRequest, type CancelCronQuery, type CronDTO, type CronRunDTO, type CronScopeQuery, type CronShowDTO, type ListCronsQuery, type PokeCronsResult } from './dto/crons.js';
 import type { NodeConfigPatch } from './dto/config.js';
 import type { AttachEnsureRequest, AttachEnsureResultDTO } from './dto/attach.js';
 import type { EnsureProfileRequest, ProfileDTO } from './dto/profiles.js';
 import type { FilePeekDTO } from './dto/files.js';
+import type { MemoryDocRefDTO } from './dto/memory.js';
 import type { CredentialRemovalResultDTO, CredentialResultDTO, InstallCredentialRequest, ModelAuthListDTO } from './dto/modelauth.js';
 import type { CreateHumanBridgeRequest, HumanBridgeResultDTO, HumanCancelRequest, HumanCancelResultDTO, HumanResolveRequest, HumanResolveResultDTO } from './dto/human.js';
 import type { CancelReviewRequest, CreateReviewRequest, ListReviewsQuery, ReviewCancelResultDTO, ReviewDocumentBaseDTO, ReviewDTO, ReviewListDTO, ReviewSubmitResultDTO } from './dto/reviews.js';
 import type { CreateReviewCommentRequest, EditReviewCommentRequest, ListReviewCommentsQuery, ReadReviewCommentEventsQuery, ReviewCommentActionRequest, ReviewCommentDetailDTO, ReviewCommentEventsDTO, ReviewCommentListDTO, ReviewCommentMutationDTO, ReviewCommentRangeBatchRequest, ReviewCommentRangeBatchResultDTO } from './dto/review-comments.js';
-import type { InboxListDTO } from './dto/inbox.js';
+import type { CancelInboxTicketRequest, CanceledTicketResultDTO, DeckTicketResultDTO, InboxDeckDTO, InboxListDTO, InboxTicketIdDTO, RespondInboxDeckRequest } from './dto/inbox.js';
 import type { AttentionCountsDTO, AttentionDTO, DashboardDTO, DashboardQuery, HistoryGrepQuery, HistoryGrepResultDTO, HistoryReadQuery, HistoryReadResultDTO, HistorySearchQuery, HistorySearchResultDTO, PruneRequest, PruneResultDTO, RebuildIndexResultDTO, RosterDTO, SnapshotDTO } from './dto/canvas.js';
 import type { CloseWorktreeResultDTO } from './dto/worktree.js';
 import type { BrokerExtensionStateDTO, BrokerGeneratedNameRequest, BrokerGeneratedNameResultDTO, BrokerInboxCursorDirective, BrokerInboxCursorRequest, BrokerModelCommitRequest, BrokerModelCommitResultDTO, BrokerPersonaAckRequest, BrokerSessionBoundRequest, BrokerSessionBoundResultDTO, BrokerSettleDirective, BrokerSettleRequest } from './dto/broker-ops.js';
@@ -131,6 +132,10 @@ export declare class CrtrClient {
     runCron(cronId: string, q?: CronScopeQuery): Promise<CronRunDTO>;
     /** Cancel one cron (`DELETE /v1/crons/:cronId`, idempotent). */
     cancelCron(cronId: string, q?: CancelCronQuery): Promise<void>;
+    /** Bare eligibility poke (`POST /v1/crons/poke`): re-dues every held active
+     *  cron now — "something changed; re-check now". Canvas-wide, label-free,
+     *  idempotent, and free when nothing is held. */
+    pokeCrons(): Promise<PokeCronsResult>;
     ensureAttach(id: string, req?: AttachEnsureRequest): Promise<AttachEnsureResultDTO>;
     getReports(id: string, q?: ReportsQuery): Promise<ReportDTO[]>;
     getTranscript(id: string, q?: TranscriptQuery): Promise<TranscriptDTO>;
@@ -143,6 +148,10 @@ export declare class CrtrClient {
     /** Read an absolute host path as UTF-8 (capped, `truncated` when clipped) for
      *  the browser file-peek panel. */
     peekFile(path: string): Promise<FilePeekDTO>;
+    /** Resolve a `[[name]]` memory-document link to the absolute path the given
+     *  node would read — the node's own precedence chain, not this process's.
+     *  Pair with `peekFile` to render the document. */
+    resolveMemoryDoc(name: string, nodeId: string): Promise<MemoryDocRefDTO>;
     ensureProfile(name: string, req?: EnsureProfileRequest): Promise<ProfileDTO>;
     listProfiles(): Promise<ProfileDTO[]>;
     getProfile(name: string): Promise<ProfileDTO>;
@@ -179,7 +188,17 @@ export declare class CrtrClient {
     resolveReviewComment(commentId: string, req?: ReviewCommentActionRequest): Promise<ReviewCommentMutationDTO>;
     reopenReviewComment(commentId: string, req?: ReviewCommentActionRequest): Promise<ReviewCommentMutationDTO>;
     deleteReviewComment(commentId: string, req?: ReviewCommentActionRequest): Promise<ReviewCommentMutationDTO>;
+    /** Pending deck/review tickets across every available crouter-owned
+     *  humanloop root. */
     listHumanInbox(): Promise<InboxListDTO>;
+    /** Read one pending deck by its opaque ticket id, with Markdown bodies
+     *  resolved inline. */
+    getHumanInboxDeck(ticketId: InboxTicketIdDTO): Promise<InboxDeckDTO>;
+    /** Submit ordered interaction responses for a pending deck. Single-assignment
+     *  server-side: a competing resolution races to `ticket_already_resolved`. */
+    respondHumanInboxDeck(ticketId: InboxTicketIdDTO, request: RespondInboxDeckRequest): Promise<DeckTicketResultDTO>;
+    /** Cancel a pending deck (terminal response, never deletion). */
+    cancelHumanInboxTicket(ticketId: InboxTicketIdDTO, request?: CancelInboxTicketRequest): Promise<CanceledTicketResultDTO>;
     /** Composed client-side from `GET /v1/nodes` + `GET /v1/status` (spec §6.3 —
      *  the dashboard is absorbed into those two reads; there is no single route).
      *  `generated_at` is the client-side capture instant of the composition. */
@@ -217,6 +236,12 @@ export declare class CrtrClient {
      *  it raw, so a value carrying `/`, whitespace or `?` would corrupt the
      *  request line rather than 404 cleanly. Mirrors `nodePath`. */
     private cronPath;
+    /** Validate an opaque inbox ticket id before route construction. A local
+     *  shape violation is a caller bug, not a server-rejectable request — throws
+     *  `TypeError` (matching the existing safe-segment discipline of a local
+     *  precondition, distinct from `nodePath`'s `ApiError` because that one IS a
+     *  request the server could plausibly receive and reject itself). */
+    private ticketId;
     /** Validate a review id before route construction (D-A6). Reviews are minted
      *  and addressed like node ids, but arrive from agent argv, so a malformed
      *  one is a plausible request the server would also reject — `ApiError`,

package/dist/api/client.js

@@ -227,6 +227,12 @@ export class CrtrClient {
     async cancelCron(cronId, q) {
         await this.request('DELETE', withQuery(routes.cron(this.cronPath(cronId)), q));
     }
+    /** Bare eligibility poke (`POST /v1/crons/poke`): re-dues every held active
+     *  cron now — "something changed; re-check now". Canvas-wide, label-free,
+     *  idempotent, and free when nothing is held. */
+    pokeCrons() {
+        return this.request('POST', routes.cronsPoke(), {});
+    }
     ensureAttach(id, req) {
         return this.request('POST', routes.nodeAttach(this.nodePath(id)), req ?? {});
     }
@@ -257,6 +263,13 @@ export class CrtrClient {
     peekFile(path) {
         return this.request('GET', withQuery(routes.filePeek(), { path }));
     }
+    // ---- Memory documents --------------------------------------------------
+    /** Resolve a `[[name]]` memory-document link to the absolute path the given
+     *  node would read — the node's own precedence chain, not this process's.
+     *  Pair with `peekFile` to render the document. */
+    resolveMemoryDoc(name, nodeId) {
+        return this.request('GET', withQuery(routes.memoryResolve(), { name, node: nodeId }));
+    }
     // ---- Profiles ----------------------------------------------------------
     ensureProfile(name, req) {
         return this.request('PUT', routes.profile(name), req ?? {});
@@ -351,10 +364,26 @@ export class CrtrClient {
     deleteReviewComment(commentId, req = {}) {
         return this.request('POST', routes.humanCommentDelete(this.commentPath(commentId)), req);
     }
-    // ---- Attached terminal viewer inbox -------------------------------------
+    // ---- Humanloop inbox (Northlight crouter-inbox v1, inbox-contract.md §A) --
+    /** Pending deck/review tickets across every available crouter-owned
+     *  humanloop root. */
     listHumanInbox() {
         return this.request('GET', routes.humanInbox());
     }
+    /** Read one pending deck by its opaque ticket id, with Markdown bodies
+     *  resolved inline. */
+    getHumanInboxDeck(ticketId) {
+        return this.request('GET', routes.humanInboxTicket(this.ticketId(ticketId)));
+    }
+    /** Submit ordered interaction responses for a pending deck. Single-assignment
+     *  server-side: a competing resolution races to `ticket_already_resolved`. */
+    respondHumanInboxDeck(ticketId, request) {
+        return this.request('POST', routes.humanInboxRespond(this.ticketId(ticketId)), request);
+    }
+    /** Cancel a pending deck (terminal response, never deletion). */
+    cancelHumanInboxTicket(ticketId, request) {
+        return this.request('POST', routes.humanInboxCancel(this.ticketId(ticketId)), request ?? {});
+    }
     // ---- Canvas reads / maintenance ---------------------------------------
     /** Composed client-side from `GET /v1/nodes` + `GET /v1/status` (spec §6.3 —
      *  the dashboard is absorbed into those two reads; there is no single route).
@@ -446,6 +475,17 @@ export class CrtrClient {
         }
         return id;
     }
+    /** Validate an opaque inbox ticket id before route construction. A local
+     *  shape violation is a caller bug, not a server-rejectable request — throws
+     *  `TypeError` (matching the existing safe-segment discipline of a local
+     *  precondition, distinct from `nodePath`'s `ApiError` because that one IS a
+     *  request the server could plausibly receive and reject itself). */
+    ticketId(id) {
+        if (!/^[a-f0-9]{64}$/.test(id)) {
+            throw new TypeError(`invalid inbox ticket id: ${JSON.stringify(id)}`);
+        }
+        return id;
+    }
     /** Validate a review id before route construction (D-A6). Reviews are minted
      *  and addressed like node ids, but arrive from agent argv, so a malformed
      *  one is a plausible request the server would also reject — `ApiError`,

package/dist/api/dto/broker.d.ts

@@ -28,6 +28,38 @@ export interface BrokerWelcomeSnapshot<M = unknown> {
 export interface BrokerWelcomeFrame<M = unknown> {
     type: 'welcome';
     snapshot?: BrokerWelcomeSnapshot<M>;
+    /** The last few id-bearing user-message dispatches from the broker's message
+     *  ledger, oldest first — so a reattaching follower can key the snapshot's
+     *  trailing user wakes by id (the id a sender minted via `message_id` on
+     *  `POST .../messages`) instead of discarding them heuristically. Live-process
+     *  memory only: a broker restart loses it. Absent on a broker pinned to an
+     *  older runtime generation. */
+    recentUserMessages?: Array<{
+        id: string;
+        text: string;
+    }>;
+}
+/**
+ * The additive identity fields the broker sets on a relayed pi `queue_update`:
+ * id arrays PARALLEL to pi's text arrays (`steeringIds[i]` identifies
+ * `steering[i]`). Sender-minted when the send carried `message_id`,
+ * broker-minted otherwise. Absent on a broker pinned to an older runtime
+ * generation — consumers fall back to bare texts. Intersect with the pinned pi
+ * `queue_update` event shape to read them typed.
+ */
+export interface RelayedQueueUpdateIdentity {
+    steeringIds?: string[];
+    followUpIds?: string[];
+}
+/**
+ * The additive identity field the broker sets on a relayed USER-role
+ * `message_start`: the message's crouter id — the `message_id` its sender
+ * minted, or a broker-minted one. Absent when the message carries none (an
+ * engine-command expansion, a pre-ledger replay, an older broker). Intersect
+ * with the pinned pi `message_start` event shape to read it typed.
+ */
+export interface RelayedUserMessageStartIdentity {
+    crtrMessageId?: string;
 }
 /**
  * The broker-control frames a relay consumer reads: `welcome` (catch-up snapshot)

package/dist/api/dto/crons.d.ts

@@ -53,6 +53,14 @@ export interface CronDTO {
     sink: string | null;
     tier: string;
     state: CronStateDTO;
+    /** True while the row is parked by the exit-75 owed-gate disposition: the
+     *  last scheduled run declared "owed but not currently eligible", so the
+     *  occurrence was not spent. A daemon poke re-dues it now; otherwise a
+     *  recurring row re-checks at its natural `fire_at` slot (the backstop) and
+     *  a held one-shot waits for a poke until `expires_at` deletes it. `state`
+     *  stays honest (active|paused) — renderers derive; an active held row must
+     *  never present as paused. */
+    held: boolean;
     run_state: CronRunStateDTO;
     /** Recent health: the most recent settled run, or null if it never ran. */
     last_run: CronLastRunDTO | null;
@@ -93,6 +101,15 @@ export interface CronRunDTO {
     /** What the sink did with this run's output, or why it didn't. */
     delivered: string | null;
 }
+/** `POST /v1/crons/poke` — the bare daemon-level eligibility poke. Re-dues
+ *  every held active cron now; paused rows keep their held state. Idempotent
+ *  and free when nothing is held. */
+export interface PokeCronsResult {
+    /** How many held rows were re-dued — for the caller's log line. */
+    unparked: number;
+    /** The poke receipt instant (UTC). */
+    at: IsoTime;
+}
 /** `GET /v1/crons/:cronId` — one cron with its run-log ring (most recent first). */
 export interface CronShowDTO {
     cron: CronDTO;

package/dist/api/dto/human.d.ts

@@ -1,4 +1,5 @@
 import type { NodeIdDTO } from './common.js';
+import type { InteractionResponseDTO } from './inbox.js';
 /** One anchored review comment, mirroring crouter's ticket-store shape as a
  *  plain structural wire type (no store import). */
 export interface FeedbackCommentDTO {
@@ -36,13 +37,6 @@ export interface FeedbackResultDTO {
     commentsTotal: number;
     commentsUnresolved: number;
 }
-export interface InteractionResponseDTO {
-    id: string;
-    selectedOptionId?: string;
-    selectedOptionIds?: string[];
-    freetext?: string;
-    optionComments?: Record<string, string>;
-}
 /** `POST /v1/human/tickets/{node_id}/resolve` body — a deck answer. */
 export interface HumanResolveRequest {
     responses: InteractionResponseDTO[];

package/dist/api/dto/inbox.d.ts

@@ -1,6 +1,7 @@
 import type { IsoTime } from './common.js';
 /** Opaque, stable, URL-safe ticket id: lowercase SHA-256 hex of
- *  `canonicalRoot + "\0" + ticketBasename`. */
+ *  `canonicalRoot + "\0" + ticketBasename`. Clients must treat it as opaque —
+ *  it discloses no home filesystem path. */
 export type InboxTicketIdDTO = string;
 export type InteractionKindDTO = 'notify' | 'decision' | 'context' | 'error' | 'review';
 export interface DeckSourceDTO {
@@ -32,3 +33,72 @@ export type InboxTicketSummaryDTO = DeckTicketSummaryDTO | ReviewTicketSummaryDT
 export interface InboxListDTO {
     tickets: InboxTicketSummaryDTO[];
 }
+export interface InteractionOptionDTO {
+    id: string;
+    label: string;
+    description?: string;
+}
+export interface InteractionPreAnswerDTO {
+    selectedOptionId?: string;
+    selectedOptionIds?: string[];
+    freetext?: string;
+    label?: string;
+}
+export interface InteractionDTO {
+    id: string;
+    title: string;
+    subtitle: string;
+    /** Resolved source Markdown — `bodyPath` is deliberately impossible here. */
+    body?: string;
+    options: InteractionOptionDTO[];
+    multiSelect?: boolean;
+    allowFreetext?: boolean;
+    freetextLabel?: string;
+    kind?: InteractionKindDTO;
+    preAnswered?: InteractionPreAnswerDTO;
+}
+export interface DeckDTO {
+    title: string;
+    source?: DeckSourceDTO;
+    interactions: InteractionDTO[];
+}
+/** `GET /v1/human/inbox/:ticket_id` result for a pending deck. */
+export interface InboxDeckDTO {
+    ticket_id: InboxTicketIdDTO;
+    kind: 'deck';
+    deck: DeckDTO;
+}
+export interface InteractionResponseDTO {
+    id: string;
+    selectedOptionId?: string;
+    selectedOptionIds?: string[];
+    freetext?: string;
+    optionComments?: Record<string, string>;
+}
+/** `POST /v1/human/inbox/:ticket_id/respond` body. */
+export interface RespondInboxDeckRequest {
+    responses: InteractionResponseDTO[];
+}
+/** `POST /v1/human/inbox/:ticket_id/respond` result — the canonical humanloop
+ *  `humanloop.response/v2` result, unchanged. */
+export interface DeckTicketResultDTO {
+    schema: 'humanloop.response/v2';
+    kind: 'deck';
+    responses: InteractionResponseDTO[];
+    summary: string;
+    completedAt: IsoTime;
+}
+/** `POST /v1/human/inbox/:ticket_id/cancel` body. `reason`, when present, must
+ *  be nonempty after trim and at most 1000 characters. */
+export interface CancelInboxTicketRequest {
+    reason?: string;
+}
+/** `POST /v1/human/inbox/:ticket_id/cancel` result — the canonical humanloop
+ *  `humanloop.cancel/v1` result, unchanged. `actor` is always `"human"`. */
+export interface CanceledTicketResultDTO {
+    schema: 'humanloop.cancel/v1';
+    kind: 'canceled';
+    canceledAt: IsoTime;
+    reason?: string;
+    actor?: string;
+}

package/dist/api/dto/inbox.js

@@ -1,2 +1,10 @@
-// Ticket summaries rendered by the attached terminal viewer.
+// Humanloop inbox DTOs — crtrd `/v1/human/inbox` (Northlight crouter-inbox v1,
+// inbox-contract.md §A). Crouter API envelope fields use the existing
+// snake_case convention; nested humanloop protocol objects retain their
+// canonical camelCase field names so they cross the wire without translation
+// or loss. Optional fields are omitted when absent, never serialized as
+// `null`. `bodyPath` is deliberately impossible on this wire — crtrd resolves
+// it server-side via humanloop's `parseDeck` and returns inline `body`.
+//
+// PURITY (spec §3.1): Node built-ins + `src/api/*` only.
 export {};

package/dist/api/dto/memory.d.ts

@@ -0,0 +1,17 @@
+/** `GET /v1/memory/resolve?name=<name>&node=<id>` result — where the named
+ *  document lives for that node. Resolution runs the node's own precedence
+ *  chain (its context store, its project stack, its profile, user, builtin), so
+ *  the same name can answer with different documents for different nodes. */
+export interface MemoryDocRefDTO {
+    /** The document's canonical identity (its frontmatter `name`, else its
+     *  path-derived name) — which may differ from the queried name when the query
+     *  was a bare leaf or a directory whose INDEX resolved. */
+    name: string;
+    /** Which store it came from: node | project | profile | user | builtin. */
+    scope: string;
+    /** Absolute path to the `.md` file. */
+    path: string;
+    /** The owning plugin's name when the doc is mounted from an installed plugin,
+     *  absent for a native scope doc. */
+    plugin?: string;
+}

package/dist/api/dto/memory.js

@@ -0,0 +1,6 @@
+// Memory-document resolution DTO. Backs `GET /v1/memory/resolve` — a client
+// holding a `[[name]]` link out of a node's transcript turns it into the
+// absolute path of the document that node would read, then peeks that path.
+//
+// PURITY (spec §3.1): Node built-ins + `src/api/*` only.
+export {};

package/dist/api/dto/messages.d.ts

@@ -26,6 +26,11 @@ export interface SendMessageRequest {
      *  body only — rejected with fresh/reopen/situational_context/
      *  output_schema or tier 'deferred'. Absent → durable inbox (unchanged). */
     delivery?: 'interactive';
+    /** Sender-minted message identity for a `delivery:'interactive'` send. The
+     *  broker mirrors it through pi's queues and echoes it on the relayed user
+     *  `message_start` (`crtrMessageId`), so an optimistic sender (the gateway)
+     *  retires its pending entry by exact id. Ignored on the durable-inbox path. */
+    message_id?: string;
 }
 /** Result of an immediate message send. */
 export interface MessageResultDTO {

package/dist/api/dto/reviews.d.ts

@@ -38,6 +38,9 @@ export interface ReviewDTO {
     created: IsoTime;
     /** Daemon open timestamp, after the companion binds. */
     opened_at?: IsoTime;
+    /** When the human submitted a review whose companion was still working. The
+     *  review remains `open` until the companion goes quiet. */
+    submit_requested_at?: IsoTime;
     /** Daemon source-read status at projection time. */
     source_missing: boolean;
     /** Daemon-owned current comment-coordinate source digest. */
@@ -73,12 +76,13 @@ export interface ListReviewsQuery {
 export interface ReviewListDTO {
     reviews: ReviewDTO[];
 }
-/** Daemon-derived result of terminal review approval. */
+/** Daemon-derived result of review approval, which may still be waiting on the
+ *  review's companion. */
 export interface ReviewSubmitResultDTO {
     review: ReviewDTO;
-    /** Immutable approval result. */
-    result: FeedbackResultDTO;
-    outcome: 'settled' | 'already_settled';
+    /** Immutable approval result; absent while the approval awaits the companion. */
+    result?: FeedbackResultDTO;
+    outcome: 'settled' | 'already_settled' | 'awaiting_companion';
 }
 /** Daemon-derived result of terminal review cancellation. */
 export interface ReviewCancelResultDTO {

package/dist/api/index.d.ts

@@ -21,6 +21,7 @@ export * from './dto/canvas.js';
 export * from './dto/worktree.js';
 export * from './dto/human.js';
 export * from './dto/files.js';
+export * from './dto/memory.js';
 export * from './dto/inbox.js';
 export * from './dto/reviews.js';
 export * from './dto/review-comments.js';

package/dist/api/index.js

@@ -22,6 +22,7 @@ export * from './dto/canvas.js';
 export * from './dto/worktree.js';
 export * from './dto/human.js';
 export * from './dto/files.js';
+export * from './dto/memory.js';
 export * from './dto/inbox.js';
 export * from './dto/reviews.js';
 export * from './dto/review-comments.js';

package/dist/api/routes.d.ts

@@ -46,6 +46,7 @@ export declare const routes: {
     readonly cronPause: (cronId: string) => string;
     readonly cronResume: (cronId: string) => string;
     readonly cronRun: (cronId: string) => string;
+    readonly cronsPoke: () => string;
     readonly canvasAttention: () => string;
     readonly canvasAttentionCounts: () => string;
     readonly canvasHistorySearch: () => string;
@@ -73,9 +74,13 @@ export declare const routes: {
     readonly humanCommentReopen: (commentId: string) => string;
     readonly humanCommentDelete: (commentId: string) => string;
     readonly humanInbox: () => string;
+    readonly humanInboxTicket: (ticketId: string) => string;
+    readonly humanInboxRespond: (ticketId: string) => string;
+    readonly humanInboxCancel: (ticketId: string) => string;
     readonly profiles: () => string;
     readonly profile: (name: string) => string;
     readonly modelAuths: () => string;
     readonly modelAuth: (provider: string) => string;
     readonly filePeek: () => string;
+    readonly memoryResolve: () => string;
 };

package/dist/api/routes.js

@@ -67,6 +67,7 @@ export const routes = {
     cronPause: (cronId) => `${V}/crons/${cronId}/pause`,
     cronResume: (cronId) => `${V}/crons/${cronId}/resume`,
     cronRun: (cronId) => `${V}/crons/${cronId}/run`,
+    cronsPoke: () => `${V}/crons/poke`,
     // Canvas maintenance / reads
     canvasAttention: () => `${V}/canvas/attention`,
     canvasAttentionCounts: () => `${V}/canvas/attention/counts`,
@@ -98,8 +99,11 @@ export const routes = {
     humanCommentResolve: (commentId) => `${V}/human/comments/${commentId}/resolve`,
     humanCommentReopen: (commentId) => `${V}/human/comments/${commentId}/reopen`,
     humanCommentDelete: (commentId) => `${V}/human/comments/${commentId}/delete`,
-    // Attached terminal viewer inbox
+    // Humanloop inbox (Northlight crouter-inbox v1, inbox-contract.md §A)
     humanInbox: () => `${V}/human/inbox`,
+    humanInboxTicket: (ticketId) => `${V}/human/inbox/${ticketId}`,
+    humanInboxRespond: (ticketId) => `${V}/human/inbox/${ticketId}/respond`,
+    humanInboxCancel: (ticketId) => `${V}/human/inbox/${ticketId}/cancel`,
     // Profiles (server-side for P2 Core; CLI profile verbs stay fs-local)
     profiles: () => `${V}/profiles`,
     profile: (name) => `${V}/profiles/${name}`,
@@ -109,4 +113,7 @@ export const routes = {
     // Host file read (browser file-peek panel). The absolute path rides as a
     // `path` query param, not a path segment — it is not a single safe segment.
     filePeek: () => `${V}/files/peek`,
+    // Memory-document resolution (a `[[name]]` link in a node's transcript). Both
+    // the name and the node it is resolved for ride as query params.
+    memoryResolve: () => `${V}/memory/resolve`,
 };

package/dist/build-root.d.ts

@@ -2,6 +2,13 @@ import type { RootDef } from './core/command.js';
 /** Every shipped subtree name. Cheap (no module loading) — the front-door
  *  recursion guard and the dispatcher's first-token routing need only names. */
 export declare const SUBTREE_NAMES: readonly string[];
+/** Every core command path, space-joined ("cron", "cron add", …) — the set
+ *  plugin `helpAddenda` keys are validated against at the strict gates
+ *  (install, bundle parse, doctor/inspect reports). Loads every core subtree,
+ *  so call it only from those gates, never on a dispatch path. Passthrough
+ *  branches are excluded: crtr never renders their help, so an addendum
+ *  targeting one could never appear. */
+export declare function coreCommandPaths(): Promise<ReadonlySet<string>>;
 /** Build a root that contains only the subtree `first` dispatches into.
  *  Returns the FULL root when `first` is not a recognized subtree — bare `crtr`,
  *  `-h`/`--help`, `--version`, and any unknown leading token all need the

package/dist/build-root.js

@@ -23,6 +23,27 @@ const SUBTREE_LOADERS = {
 /** Every shipped subtree name. Cheap (no module loading) — the front-door
  *  recursion guard and the dispatcher's first-token routing need only names. */
 export const SUBTREE_NAMES = Object.freeze(Object.keys(SUBTREE_LOADERS));
+/** Every core command path, space-joined ("cron", "cron add", …) — the set
+ *  plugin `helpAddenda` keys are validated against at the strict gates
+ *  (install, bundle parse, doctor/inspect reports). Loads every core subtree,
+ *  so call it only from those gates, never on a dispatch path. Passthrough
+ *  branches are excluded: crtr never renders their help, so an addendum
+ *  targeting one could never appear. */
+export async function coreCommandPaths() {
+    const core = await Promise.all(SUBTREE_NAMES.map((n) => SUBTREE_LOADERS[n]()));
+    const paths = new Set();
+    const visit = (node, prefix) => {
+        if (node.kind === 'branch' && node.passthrough !== undefined)
+            return;
+        paths.add(prefix);
+        if (node.kind === 'branch')
+            for (const child of node.children)
+                visit(child, `${prefix} ${child.name}`);
+    };
+    for (const subtree of core)
+        visit(subtree, subtree.name);
+    return paths;
+}
 /** Build a root that contains only the subtree `first` dispatches into.
  *  Returns the FULL root when `first` is not a recognized subtree — bare `crtr`,
  *  `-h`/`--help`, `--version`, and any unknown leading token all need the

package/dist/builtin-memory/insights/init.md

@@ -8,11 +8,15 @@ slash: true
 rationale: Ordinary conversations, corrections, answers to `crtr human ask`, and review comments carry unique user knowledge that agents inconsistently recognize or save; when agents do infer a deeper principle, they have written it without first letting the user correct the extrapolation.
 ---
 
-# /insights:init — begin passive domain listening
+# /insights:init — begin domain listening
 
-Initialize an ordinary memory directory that listens for user-derived insight about this domain. This version is passive: do not start research, schedule work, create a standing node, or proactively question the user after initialization.
+Initialize an ordinary memory directory that listens for user-derived insight about this domain.
 
-**Requested domain:** $ARGUMENTS
+**Requested domain and mode:** $ARGUMENTS
+
+## Check for --active flag
+
+If `$ARGUMENTS` contains `--active`, follow the **active mode** steps below. Otherwise, follow the **passive mode** steps.
 
 ## Establish the topic and scope
 
@@ -43,3 +47,44 @@ Keep the body short. It contains:
 Do not copy the capture workflow into the listener. The link keeps that process in one maintained place. Do not create placeholder principle documents.
 
 Run `crtr memory lint`, fix every finding, then report the canonical listener name, selected scope, and the domain boundary. Initialization is complete once the routed listener exists; no independent work follows.
+
+## Active mode: research and surface claims
+
+When `--active` is present, do not stop after creating the listener. After initialization:
+
+### 1. Create the listener first
+
+Follow the passive mode steps above through "Initialization is complete." The listener INDEX must exist before spawning the explorer.
+
+### 2. Spawn the explorer child
+
+Run this exact command, replacing `<topic>` with the topic slug you chose above:
+
+```bash
+crtr node new --kind explore --name "explore-<topic>" <<'TASK'
+Investigate the domain "<topic>" thoroughly. Your goal is to surface 3–5 distinct, falsifiable claims or questions about how this domain works, what its gaps are, or what fundamental principles govern it. Each claim should be specific enough that the user can confirm it, refine it, or reject it outright.
+
+Gather evidence from code, docs, existing understanding, and project artifacts. Then present your claims clearly:
+
+**Claim 1:** [claim text]
+**Evidence:** [why you believe this]
+**Question:** [what would prove or disprove this?]
+
+Repeat for each claim. Write findings to $CRTR_CONTEXT_DIR/claims.md and report the absolute path.
+TASK
+```
+
+Do not wait for the explorer to finish—it runs in parallel. Move to the next step while it works.
+
+### 3. Coordinate user responses and capture flow
+
+When the explorer reports, share its claims with the user. For each claim, ask:
+- Does this ring true?
+- Is it incomplete or wrong?
+- What's the actual principle?
+
+For each user response, use [[insights/capture]] to extract and review the insight. Apply approved insights directly to the listener INDEX's `Approved insights` section.
+
+### 4. Report completion
+
+Once claims have been surfaced and user guidance has generated approved insights, report that active initialization is complete. The listener INDEX now passively captures this domain as new user material emerges.