@north-light/crouter 0.3.154

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

@@ -0,0 +1,57 @@
+import type { IsoTime, NodeIdDTO } from './common.js';
+export type ConsultKindDTO = 'follow_up' | 'visual';
+/** A consult-outbox entry (the canvas half of a human consult/visual request). */
+export interface ConsultOutboxEntryDTO {
+    request_id: string;
+    node_id: NodeIdDTO;
+    kind: ConsultKindDTO;
+    dir: string;
+    created: IsoTime;
+}
+/** `GET /v1/canvas/consults` result. */
+export interface ConsultOutboxDTO {
+    entries: ConsultOutboxEntryDTO[];
+}
+/** `POST /v1/canvas/consults` body. */
+export interface CreateConsultRequest {
+    node_id: NodeIdDTO;
+    kind: ConsultKindDTO;
+    request_id: string;
+    dir: string;
+    root: string;
+}
+/** Result of enqueuing a consult. */
+export interface ConsultResultDTO {
+    request_id: string;
+    created: boolean;
+}
+/** `POST /v1/human/bridge` body — create a terminal `kind:'human'` bridge node
+ *  via `spawnNode` (NO broker engine). Distinct from `POST /v1/nodes`, whose
+ *  `spawnChild` always launches a broker the bridge must never have. */
+export interface CreateHumanBridgeRequest {
+    kind: 'human';
+    parent: NodeIdDTO | null;
+    cwd: string;
+    name: string;
+}
+/** `POST /v1/human/bridge` result — the minted bridge node id + its name. */
+export interface HumanBridgeResultDTO {
+    node_id: NodeIdDTO;
+    name: string;
+}
+/** `POST /v1/human/deliver` result — the registered humanloop completion
+ *  handler run server-side. */
+export interface HumanDeliverResultDTO {
+    delivered: boolean;
+}
+/** `POST /v1/human/consult` result — the registered follow-up handler run
+ *  server-side. `handled` communicates whether an action was taken (never a
+ *  throw for a stale/superseded event). */
+export interface HumanConsultResultDTO {
+    handled: boolean;
+}
+/** `POST /v1/human/visual` result — the registered visual handler run
+ *  server-side. */
+export interface HumanVisualResultDTO {
+    handled: boolean;
+}

package/dist/api/dto/human.js

@@ -0,0 +1,4 @@
+// Human-bridge DTOs — the CANVAS HALF ONLY (spec §6.5). The humanloop
+// ticket/deck store is an external package and stays local; these cover the
+// `consult_outbox` rows that route through crtrd.
+export {};

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

@@ -0,0 +1,105 @@
+import type { IsoTime } from './common.js';
+/** Opaque, stable, URL-safe ticket id: lowercase SHA-256 hex of
+ *  `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 {
+    sessionName?: string;
+    askedBy?: string;
+    blockedSince?: IsoTime;
+    nodeId?: string;
+    visual?: 'humanloop.visual/v1';
+}
+export interface DeckTicketSummaryDTO {
+    ticket_id: InboxTicketIdDTO;
+    kind: 'deck';
+    title: string;
+    subtitle: string;
+    blocked_since: IsoTime;
+    source: DeckSourceDTO;
+    interaction_kind?: InteractionKindDTO;
+}
+export interface ReviewTicketSummaryDTO {
+    ticket_id: InboxTicketIdDTO;
+    kind: 'review';
+    title: string;
+    subtitle: string;
+    blocked_since: IsoTime;
+    source: DeckSourceDTO;
+}
+export type InboxTicketSummaryDTO = DeckTicketSummaryDTO | ReviewTicketSummaryDTO;
+/** `GET /v1/human/inbox` result. `tickets` is sorted newest `blocked_since`
+ *  first, then `ticket_id` ascending. */
+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

@@ -0,0 +1,10 @@
+// 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/lifecycle.d.ts

@@ -0,0 +1,79 @@
+import type { NodeIdDTO, NodeStatusDTO } from './common.js';
+/** `POST /v1/nodes/{id}/revive` body. */
+export interface ReviveRequest {
+    /** Resume the saved conversation (true) vs a fresh launch (false). */
+    resume?: boolean;
+    /** Clear the finalization latch before reviving (#339 `--reopen` gate). The
+     *  latch clear is a canvas write, so the gate is enforced server-side: with
+     *  `reopen:false` (default) a finalized node is REJECTED (`node_finalized`);
+     *  with `reopen:true` a node that is NOT finalized is rejected
+     *  (`not_finalized`). */
+    reopen?: boolean;
+    /** Wake provenance: the cron whose run drove this revive (`CRTR_CRON_ID`,
+     *  set by the daemon in every cron run's environment and forwarded by the
+     *  CLI). With `resume:false` and a still-live cron row, crtrd injects the
+     *  `<crtr-wake>` block so the revived node learns a CLOCK woke it, not a
+     *  message. Prose only — an unknown id is ignored, never an error. */
+    cron_id?: string;
+}
+/** Result of a revive. `revived` is false on the idempotent double-revive no-op. */
+export interface ReviveResultDTO {
+    node_id: NodeIdDTO;
+    revived: boolean;
+    resumed: boolean;
+    status: NodeStatusDTO;
+}
+/** `POST /v1/nodes/{id}/relaunch-root` result. A null id means the target
+ * was not a relaunchable live root, or its replacement failed to launch. */
+export interface RelaunchRootResultDTO {
+    newNodeId: NodeIdDTO | null;
+}
+/** `POST /v1/nodes/revive-all` result. Node ids relaunched, plus any that
+ *  failed to revive with the reason (the reader reports both). */
+export interface ReviveAllResultDTO {
+    revived: NodeIdDTO[];
+    failed: {
+        node_id: NodeIdDTO;
+        error: string;
+    }[];
+}
+/** `POST /v1/nodes/{id}/close` body. The cascade set is computed server-side
+ *  from edges; the flag only opts out of cascading descendants. */
+export interface CloseRequest {
+    cascade?: boolean;
+    /** Root close disposition: `true` finalizes the root to `done` (the browse `x`
+     *  "finish" semantics); default/`false` cancels it. The cascade set (computed
+     *  server-side) is torn down either way. */
+    finish?: boolean;
+}
+/** Result of a close. */
+export interface CloseResultDTO {
+    /** The closed node — the cascade root. */
+    root: NodeIdDTO;
+    /** Every node torn down (root + cascaded descendants), leaves-first. */
+    closed: NodeIdDTO[];
+    /** Descendants left alive because an out-of-subtree manager still subscribes. */
+    spared: NodeIdDTO[];
+}
+/** `POST /v1/nodes/{id}/promote` body. */
+export interface PromoteRequest {
+    /** Specialize as this kind of orchestrator; defaults to the node's current kind. */
+    kind?: string;
+    /** Also flip lifecycle→resident (interactable). */
+    resident?: boolean;
+    /** Durably change the model tier (ultra|strong). */
+    model?: string;
+}
+/** `POST /v1/nodes/{id}/yield` body. */
+export interface YieldRequest {
+    note?: string;
+    promote?: boolean;
+    /** Respecialize the kind as the node refreshes. */
+    kind?: string;
+    /** Durably raise the model tier (ultra|strong) for the fresh revive. */
+    model?: string;
+}
+/** `POST /v1/nodes/{id}/wait` body. */
+export interface WaitRequest {
+    controller: NodeIdDTO;
+}

package/dist/api/dto/lifecycle.js

@@ -0,0 +1,3 @@
+// Lifecycle action DTOs (spec §6.2). Recycle/demote take no body and return a
+// `NodeDetailDTO` (nodes.ts); revive/close/promote/yield/wait are here.
+export {};

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

@@ -0,0 +1,55 @@
+import type { InboxTierDTO, IsoTime, NodeIdDTO } from './common.js';
+/** `POST /v1/nodes/{id}/messages` body. */
+export interface SendMessageRequest {
+    body: string;
+    tier?: InboxTierDTO;
+    /** Sender node id for feed attribution (the CLI resolves `CRTR_NODE_ID`;
+     *  the daemon has no ambient caller identity). Absent → an external/human
+     *  caller (`from: null`). */
+    from?: NodeIdDTO | null;
+    /** Revive with no inbox entry (`--fresh` → `reviveNode({ resume: false })`). */
+    fresh?: boolean;
+    /** Clear a latched target's finalization latch before an immediate delivery
+     *  or `--fresh` revive (`--reopen`). Immediate only. */
+    reopen?: boolean;
+    /** Hidden ambient context upserted onto the target's sidecar and delivered as
+     *  a `<situational-context>` block, never visible chat (`--situational-context`).
+     *  Immediate only; valid alone (no body). */
+    situational_context?: string;
+    /** Raw JSON-schema string granting a one-off `submit` tool before delivery
+     *  (`--output-schema`). Immediate only. */
+    output_schema?: string;
+    /** `'interactive'`: deliver via the target's LIVE broker engine (prompt/steer
+     *  on its one serialized frame loop — the same ordering a tmux viewer gets)
+     *  instead of the durable inbox; a dormant or mid-revive target falls back to
+     *  the durable inbox + revive (watcher delivers post-boot). Plain immediate
+     *  body only — rejected with fresh/reopen/situational_context/
+     *  output_schema or tier 'deferred'. Absent → durable inbox (unchanged). */
+    delivery?: 'interactive';
+}
+/** Result of an immediate message send. */
+export interface MessageResultDTO {
+    node_id: NodeIdDTO;
+    /** Whether an inbox entry was appended now. */
+    delivered: boolean;
+    /** Whether a dormant target was revived to receive the message. */
+    revived: boolean;
+    delivered_at?: IsoTime;
+    /** Which channel a `delivery:'interactive'` send actually used: `'engine'`
+     *  (live broker frame loop, no inbox entry) or `'inbox'` (durable fallback).
+     *  Absent for non-interactive sends. */
+    delivered_via?: 'engine' | 'inbox';
+}
+/** `POST /v1/nodes/{id}/interrupt` result — the human Esc, first-class. Cancels
+ *  pending undelivered human-send inbox entries FIRST, then aborts a live
+ *  in-flight turn; a dormant target is NEVER revived. */
+export interface InterruptResultDTO {
+    node_id: NodeIdDTO;
+    /** Primary outcome: `aborted_turn` wins over `canceled_pending` over `idle`
+     *  (abort + cancel can co-occur; the flags below carry the full picture). */
+    outcome: 'aborted_turn' | 'canceled_pending' | 'idle';
+    /** True when a live in-flight turn (or `!` bash run) was actually aborted. */
+    aborted_turn: boolean;
+    /** How many pending undelivered human-send inbox entries were canceled. */
+    canceled_pending: number;
+}

package/dist/api/dto/messages.js

@@ -0,0 +1,2 @@
+// Message DTOs (spec §6.2).
+export {};

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

@@ -0,0 +1,41 @@
+/** `PUT /v1/model-auth/{provider}` body — a discriminated union over credential
+ *  kind. Idempotent upsert/rotate keyed by provider (and `account_id` for a
+ *  managed account). */
+export type InstallCredentialRequest = {
+    kind: 'api_key';
+    api_key: string;
+} | {
+    kind: 'oauth';
+    access_token: string;
+    /** Required — pi's `OAuthCredentials` always carries both; the handler is
+     *  fail-loud (400) when either is absent, so the type matches (no lenient
+     *  fallback). */
+    refresh_token: string;
+    expires_at: string;
+    account_id?: string;
+    /** Provider-specific credential keys beyond the canonical tokens (e.g.
+     *  github-copilot's `enterpriseUrl`), retained for enterprise routing and
+     *  token refresh. */
+    extra?: Record<string, unknown>;
+} | {
+    kind: 'managed_account';
+    /** Optional requested label. A bare provider login automatically labels a newly seen
+     *  account from its identity profile. */
+    label?: string;
+    auto_label?: boolean;
+    account_id?: string;
+    access_token: string;
+    /** Required — the managed login always returns both; the handler is
+     *  fail-loud (400) when either is absent. */
+    refresh_token: string;
+    expires_at: string;
+    /** Causal-cooldown floor snapshotted before the interactive login flow. Epoch ms. */
+    last_rate_limited_at?: number;
+};
+/** Result of a credential install/rotate. */
+export interface CredentialResultDTO {
+    provider: string;
+    installed: true;
+    managed: boolean;
+    account_id?: string;
+}

package/dist/api/dto/modelauth.js

@@ -0,0 +1,3 @@
+// Model-auth DTOs (spec §7.6). `PUT /v1/model-auth/{provider}` installs/rotates
+// already-obtained credential material; interactive collection stays client-side.
+export {};

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

@@ -0,0 +1,209 @@
+import type { Cursor, ExitIntentDTO, IsoTime, LifecycleDTO, ModeDTO, NodeIdDTO, NodeStatusDTO } from './common.js';
+/** `POST /v1/nodes` body. Carries the full immediate spawn recipe. */
+export interface CreateNodeRequest {
+    kind: string;
+    prompt?: string;
+    profile?: string;
+    mode?: ModeDTO;
+    cwd?: string;
+    /** Display name (tmux window + resume picker). Defaults to the kind. */
+    name?: string;
+    parent?: NodeIdDTO | null;
+    root?: boolean;
+    /** Worktree branch name, or true for an auto-named managed worktree. */
+    worktree?: string | boolean;
+    fork_from?: string;
+    model?: string;
+    situational_context?: string;
+    no_kickoff?: boolean;
+    output_schema?: string;
+    /** Spawn AT this exact node id instead of a runtime-minted one — format-
+     *  validated and duplicate-rejected server-side (`NodeIdConflictError` →
+     *  HTTP 409 `node_id_exists`). See `crtr node new --node-id`. */
+    node_id?: string;
+    /** Serve this create from the warm pool when a pre-booted spare matches the
+     *  request's frozen launch tuple (kind, mode, cwd, profile, model,
+     *  situational_context) — answering in milliseconds instead of waiting out a
+     *  full engine boot. Only a bare root with no kickoff qualifies; anything the
+     *  pool cannot honor (or an empty pool) falls back to an ordinary cold spawn,
+     *  so the flag never fails a create, it only ever makes it faster. */
+    prefer_warm?: boolean;
+}
+/** The list/queryable projection of a node — the indexed row columns. */
+export interface NodeSummaryDTO {
+    node_id: NodeIdDTO;
+    name: string;
+    kind: string;
+    mode: ModeDTO;
+    lifecycle: LifecycleDTO;
+    status: NodeStatusDTO;
+    cwd: string;
+    host_kind: 'tmux' | 'broker' | null;
+    profile_id: string | null;
+    parent: NodeIdDTO | null;
+    created: IsoTime;
+    intent: ExitIntentDTO;
+    waiting_for: NodeIdDTO | null;
+    pi_pid: number | null;
+    final_report: string | null;
+    finalized_at: IsoTime | null;
+}
+/** The spine + subscription edges of a node (absorbs `managers`/`paths` reads). */
+export interface NodeEdgesDTO {
+    /** Spine parent (my manager); null for a root. */
+    parent: NodeIdDTO | null;
+    /** Provenance — who spawned me. */
+    spawned_by: NodeIdDTO | null;
+    /** Publishers I subscribe to. */
+    subscribes_to: NodeIdDTO[];
+    /** Subscribers to my output (my managers). */
+    subscribers: NodeIdDTO[];
+    /** Children I spawned. */
+    children: NodeIdDTO[];
+}
+/** Absolute filesystem paths for a node (absorbs the `paths` read). */
+export interface NodePathsDTO {
+    node_dir: string;
+    context_dir: string;
+    reports_dir: string;
+    meta_path: string;
+    inbox_path: string;
+    transcript_path: string;
+    view_socket: string;
+}
+/** A node's managed git worktree, if any. */
+export interface NodeWorktreeDTO {
+    state: 'open' | 'closed';
+    path: string;
+    branch: string;
+    repo_root: string;
+    base_ref: string;
+    base_sha: string;
+    created: IsoTime;
+    closed?: IsoTime;
+}
+/** The full node view — summary ∪ identity extras ∪ edges ∪ paths. Returned by
+ *  `GET /v1/nodes/{id}` and by the create/lifecycle actions that yield a node. */
+export interface NodeDetailDTO extends NodeSummaryDTO {
+    description?: string;
+    cycles?: number;
+    /** Approximate context-window token load of the node's live/last session,
+     *  used by the orchestrator yield-nudge (`childFollowUp`). Null when unknown
+     *  (never launched, or no token accounting yet). */
+    context_tokens?: number | null;
+    pi_session_id?: string | null;
+    /** Launch-time process-identity fingerprint captured alongside `pi_pid`
+     *  (`NodeMeta.pi_pid_identity`), or null. Surfaced so `revive --now`'s
+     *  client-side SIGTERM can pass the identity baseline to `recordedPidLiveness`
+     *  and refuse to signal a stranger process that reused a dead broker's pid.
+     *  Null when the node predates the field or its launch-time capture failed
+     *  (fail-open — no baseline means no guard, not a false mismatch). */
+    pi_pid_identity?: string | null;
+    /** The node's durable model override (`NodeMeta.model_override`), or null when
+     *  it runs on the kind/profile default. Surfaced so `node config --model`
+     *  can report the resolved model after a patch. */
+    model_override?: string | null;
+    /** Absolute path to pi's session `.jsonl`, captured at session_start
+     *  (`NodeMeta.pi_session_file`). Distinct from `paths.transcript_path` (the
+     *  crtr-owned transcript mirror). Consumed by `memory origin` to deref a doc
+     *  back to the conversation that authored it. */
+    pi_session_file?: string | null;
+    edges: NodeEdgesDTO;
+    paths: NodePathsDTO;
+    worktree?: NodeWorktreeDTO | null;
+    /** Present only on a `POST /promote` response — the roadmap/goal facts the
+     *  promote primitive returns beyond the node meta (spec §6.2). A plain detail
+     *  read omits them. */
+    roadmap_written?: boolean;
+    roadmap_path?: string;
+    goal_path?: string;
+}
+/** `GET /v1/nodes` query filters. */
+export interface ListNodesQuery {
+    status?: NodeStatusDTO;
+    kind?: string;
+    mode?: ModeDTO;
+    /** Restrict to the subtree under this node. */
+    under?: NodeIdDTO;
+    /** Only nodes with a dangling/hanging manager edge. */
+    hanging?: boolean;
+}
+/** `GET /v1/nodes/{id}/snapshot` — the node's reconstructed broker snapshot
+ *  (`readNodeSnapshot`): the message log, aggregate stats, and current engine
+ *  state, plus the node's registered command set. */
+export interface NodeSnapshotDTO {
+    node_id: NodeIdDTO;
+    snapshot: {
+        messages: unknown[];
+        stats: unknown;
+        state: Record<string, unknown>;
+    };
+    commands: {
+        name: string;
+        description: string;
+        source: string;
+    }[];
+    captured_at: IsoTime;
+}
+/** `GET /v1/nodes/{id}/session` — the node's conversation exactly as it ran:
+ *  the raw session `.jsonl` bytes plus the assembled system prompt. Unlike
+ *  `NodeSnapshotDTO` nothing is reconstructed or flattened, so every
+ *  session-tree entry, cycle, branch, and custom message role survives. This is
+ *  what an export/download wants; `/snapshot` is what a renderer wants. */
+export interface NodeSessionDTO {
+    node_id: NodeIdDTO;
+    /** Absolute path (inside the node's host) of the file the bytes came from. */
+    session_file: string;
+    /** Verbatim `.jsonl` contents. */
+    session_jsonl: string;
+    /** Assembled system prompt as last captured, or `null` if never written. */
+    system_prompt: string | null;
+    captured_at: IsoTime;
+}
+/** `GET /v1/nodes/{id}/transcript` query. */
+export interface TranscriptQuery {
+    limit?: number;
+    cursor?: Cursor;
+}
+/** `GET /v1/nodes/{id}/transcript` result. The reader (`transcriptMarkdown`)
+ *  renders the whole conversation as a single markdown document. */
+export interface TranscriptDTO {
+    node_id: NodeIdDTO;
+    markdown: string;
+}
+/** A canvas artifact under a node (`nodeArtifacts` → `HistoryArtifact`): a
+ *  pushed report, a context doc, or the node roadmap. */
+export interface ArtifactDTO {
+    /** Stable `<node-id>:<relpath>` handle. */
+    ref: string;
+    /** Artifact source — `report:<kind>` | `doc` | `roadmap` | `meta`. */
+    source: string;
+    ts: IsoTime;
+    title: string;
+}
+/** `GET /v1/nodes/{id}/artifacts` query. Narrow to one corpus; absent is the
+ *  default report/doc/roadmap set (`inbox` is opt-in only). */
+export interface ArtifactsQuery {
+    type?: 'report' | 'doc' | 'roadmap' | 'inbox';
+}
+/** `GET /v1/nodes/{id}/artifacts` result. */
+export interface ArtifactListDTO {
+    node_id: NodeIdDTO;
+    artifacts: ArtifactDTO[];
+}
+/** One context root visible to a node — its own dir plus each publisher it
+ *  subscribes to (the shared-document roster). */
+export interface ContextRootDTO {
+    node_id: NodeIdDTO;
+    label: string;
+    dir: string;
+    /** True for the node's own context root. */
+    self: boolean;
+    /** Count of context + report files under the root. */
+    files: number;
+}
+/** `GET /v1/nodes/{id}/context` result (the listing; the nvim popup stays local). */
+export interface ContextListDTO {
+    node_id: NodeIdDTO;
+    roots: ContextRootDTO[];
+}

package/dist/api/dto/nodes.js

@@ -0,0 +1,3 @@
+// Node resource DTOs (spec §6.2): create request, summary/detail projections,
+// list query, and the node read-endpoint shapes.
+export {};

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

@@ -0,0 +1,14 @@
+/** `PUT /v1/profiles/{name}` body — idempotent ensure. */
+export interface EnsureProfileRequest {
+    /** Absolute project directories in the profile's purview. */
+    projects?: string[];
+}
+/** A profile projection. */
+export interface ProfileDTO {
+    /** Stable profile-directory id (`<slug>-<id>`). */
+    id: string;
+    name: string;
+    projects: string[];
+    /** The directory this profile is pinned as default for, if any. */
+    default_dir?: string | null;
+}

package/dist/api/dto/profiles.js

@@ -0,0 +1,3 @@
+// Profile DTOs (spec §6.6). Server-side for remote/Core (P2) consumers; local
+// `crtr profile *` verbs stay fs-local.
+export {};

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

@@ -0,0 +1,41 @@
+import type { IsoTime, NodeIdDTO } from './common.js';
+/** Report tier — `crtr push {update,urgent,final}`. */
+export type ReportTierDTO = 'update' | 'urgent' | 'final';
+/** `POST /v1/nodes/{id}/reports` body ({id} = the reporting node). */
+export interface PushReportRequest {
+    tier: ReportTierDTO;
+    body: string;
+}
+/** Result of a push. `transitioned` is present only for `final`, which drives a
+ *  server-side lifecycle transition. */
+export interface PushReportResultDTO {
+    /** Absolute path of the written report file. */
+    report_path: string;
+    /** Subscriber node ids that received an inbox entry. */
+    notified: NodeIdDTO[];
+    transitioned?: {
+        from: string;
+        to: string;
+    };
+    /** Present (and true) only for a `final` push whose reporting node owned a
+     *  managed worktree with zero commits ahead of its base and no uncommitted
+     *  changes: the server auto-dropped it instead of blocking on `node worktree
+     *  close` (#327/#333). A worktree with real unlanded work instead blocks with
+     *  an `open_managed_worktree` error. */
+    worktree_auto_dropped?: boolean;
+    /** Present only alongside `worktree_auto_dropped`: the checkout path dropped. */
+    worktree_auto_dropped_path?: string;
+}
+/** `GET /v1/nodes/{id}/reports` query filters. */
+export interface ReportsQuery {
+    tier?: ReportTierDTO;
+    limit?: number;
+}
+/** A single stored report entry. */
+export interface ReportDTO {
+    /** Absolute path of the report file. */
+    path: string;
+    tier: ReportTierDTO;
+    body: string;
+    created: IsoTime;
+}

package/dist/api/dto/reports.js

@@ -0,0 +1,2 @@
+// Push / report DTOs (spec §7.4).
+export {};

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

@@ -0,0 +1,14 @@
+import type { IsoTime, NodeIdDTO } from './common.js';
+/** `POST /v1/nodes/{id}/subscriptions` body — {id} subscribes to `target`. */
+export interface SubscribeRequest {
+    target: NodeIdDTO;
+    /** active = wake the subscriber on emit; passive = accumulate, no wake. */
+    active?: boolean;
+}
+/** A subscription as seen from one endpoint. */
+export interface SubscriptionDTO {
+    /** The node id at the other end of the edge. */
+    node_id: NodeIdDTO;
+    active: boolean;
+    created: IsoTime;
+}

package/dist/api/dto/subscriptions.js

@@ -0,0 +1,2 @@
+// Subscription DTOs (spec §6.2).
+export {};