@crouter/api 0.3.377

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

@@ -0,0 +1,172 @@
+export declare const PRIVACY_LEVELS_DTO: readonly ["public", "friends", "private"];
+export type PrivacyName = typeof PRIVACY_LEVELS_DTO[number];
+export type OwnerTypeName = 'person' | 'app' | 'repo' | 'profile' | 'node' | 'document' | 'job';
+export interface ObjectOwnerDTO {
+    id: string;
+    type: OwnerTypeName;
+    handle: string;
+}
+export interface ObjectDTO {
+    id: string;
+    /** The object's kind name: `document`, `node`, `job`, `person`, `app`, `repo`, `profile`, or a later kind. */
+    type: string;
+    kind: string | null;
+    owner: ObjectOwnerDTO | null;
+    privacy: PrivacyName;
+    name: string;
+    preview: string;
+    created_at: string;
+    deleted_at: string | null;
+}
+export interface DocHeadDTO {
+    rev_id: string;
+    number: number;
+    author_id: string | null;
+    created_at: string;
+}
+/** Optional document fields a `--fields` read returns. */
+export interface DocFieldsDTO {
+    why_it_exists?: string | null;
+    unlisted?: boolean;
+    lint_ignore?: string[];
+    extensions?: Record<string, Record<string, unknown>>;
+    rules?: import('./docs.js').DeliveryRuleDTO[];
+}
+/** `data` of a document read. */
+export interface DocumentReadData {
+    summary: string | null;
+    revision: number;
+    heads: DocHeadDTO[];
+    /** One body per head, in `heads` order. */
+    bodies: string[];
+    needs_merge: boolean;
+    /** Documents named under it, then the documents it links to not already in your context at preview, each once. */
+    listing?: ObjectDTO[];
+    /** One `<auto-loaded-context>` block: enclosing listings and documents the read's `document-read` rules delivered. */
+    attachments?: string;
+    fields?: DocFieldsDTO;
+}
+/** `data` of a node read. */
+export interface NodeReadData {
+    status: string;
+    mandate_first_line: string;
+    children: ObjectDTO[];
+    owned: ObjectDTO[];
+    jobs: ObjectDTO[];
+}
+/** `data` of a job read. */
+export interface JobReadData {
+    command: string;
+    status: string;
+    exit_code: number | null;
+    log_path: string;
+}
+/** `data` of a person, app, repo or profile read. */
+export interface OwnerReadData {
+    handle: string;
+    display_name: string;
+    identity: {
+        scheme: string;
+        external_id: string;
+    };
+}
+/** A live object: `text` is exactly what `crtr canvas read` prints; `data` holds the kind's
+ *  structured fields (for the built-in kinds, the `*ReadData` shapes above). */
+export interface ObjectLiveReadDTO {
+    state: 'object';
+    type: string;
+    object: ObjectDTO;
+    text: string;
+    data: Record<string, unknown>;
+}
+/** A pointer to a deleted object resolves to that object (§8); an answer, not an error. */
+export interface ObjectDeletedDTO {
+    state: 'deleted';
+    deleted: ObjectDTO;
+}
+/** The name's first segment is no handle on this runtime; the object may live on another runtime. */
+export interface ObjectRemoteDTO {
+    state: 'remote';
+    remote: string;
+}
+export type ObjectReadDTO = ObjectLiveReadDTO | ObjectDeletedDTO | ObjectRemoteDTO;
+export interface ObjectReadQuery {
+    fields?: boolean;
+}
+export interface ObjectListRequest {
+    /** A kind name. */
+    type?: string;
+    kind?: string;
+    /** An owner ref (name or id). */
+    owner?: string;
+    privacy?: PrivacyName;
+    /** Name prefix. */
+    name?: string;
+    deleted?: boolean;
+    limit?: number;
+    cursor?: string;
+}
+export interface ObjectListItemDTO extends ObjectDTO {
+    summary?: string | null;
+    /** A document's rule count. */
+    rules?: number;
+}
+export interface ObjectListDTO {
+    items: ObjectListItemDTO[];
+    next_cursor: string | null;
+}
+export interface ObjectSearchRequest {
+    text: string;
+    body?: boolean;
+    grep?: string;
+    /** A kind name. */
+    type?: string;
+    kind?: string;
+    owner?: string;
+    limit?: number;
+}
+export interface ObjectSearchHitDTO {
+    object: ObjectListItemDTO;
+    matches?: Array<{
+        line: number;
+        text: string;
+    }>;
+}
+export interface ObjectSearchDTO {
+    items: ObjectSearchHitDTO[];
+}
+export type ListenDeliveryName = 'interrupt' | 'steer' | 'after-turn' | 'next-turn';
+/** `{"<level 1-10>": delivery}` */
+export type ListenConfigDTO = Record<string, ListenDeliveryName>;
+export interface WatchRequest {
+    patterns?: string[];
+    config?: ListenConfigDTO;
+    filter?: Record<string, unknown>;
+    watcher?: string;
+}
+export interface UnwatchQuery {
+    pattern?: string;
+    watcher?: string;
+}
+export interface WatchResultDTO {
+    object: ObjectDTO;
+    patterns: string[];
+}
+export interface UnwatchResultDTO {
+    object: ObjectDTO;
+    removed: number;
+}
+export type EdgeTypeName = 'acted-on' | 'links-to' | 'watches';
+export interface EdgesQuery {
+    type?: EdgeTypeName;
+    direction?: 'out' | 'in';
+}
+export interface EdgeDTO {
+    type: EdgeTypeName;
+    src: ObjectDTO;
+    dst: ObjectDTO;
+    written_as?: string;
+}
+export interface EdgesDTO {
+    items: EdgeDTO[];
+}

package/dist/api/dto/objects.js

@@ -0,0 +1,5 @@
+// Canvas object DTOs — the `/v1/objects` shared verbs (read, list, search,
+// watch, unwatch, edges) over documents, nodes, jobs and owners.
+//
+// PURITY (spec §3.1): Node built-ins + `src/api/*` only.
+export const PRIVACY_LEVELS_DTO = ['public', 'friends', 'private'];

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

@@ -0,0 +1,117 @@
+/** The disclosure ladder, lowest to highest. Index order is the ordering. */
+export declare const PROFILE_PROJECT_MEMORY_VALUES: readonly ["none", "name", "preview", "content"];
+/** How much of an owner's documents automatic delivery may disclose. */
+export type ProfileProjectMemory = (typeof PROFILE_PROJECT_MEMORY_VALUES)[number];
+/** One project directory in a profile's purview. */
+export interface ProfileProject {
+    /** Absolute, real-path-resolved directory. */
+    path: string;
+}
+/** Per-owner cap on automatic `boot` and `workspace-open` delivery, keyed by
+ *  owner handle (repo, profile, app, `user`, plugin). An absent owner is
+ *  uncapped (`content`); a node's own documents are never capped. */
+export type DeliveryLimits = Record<string, ProfileProjectMemory>;
+/** `PUT /v1/profiles/{name}` body — idempotent ensure. Every field applies
+ *  only at create; an existing same-named profile is returned untouched. */
+export interface EnsureProfileRequest {
+    /** Project directories in the profile's purview. */
+    projects?: ProfileProject[];
+    /** Persona kind for node creates under the profile that omit kind. */
+    default_kind?: string;
+    /** Profile facts (identity, role); each entry reaches every broker
+     *  launched under the profile as `CRTR_PROFILE_META_<KEY>` env. */
+    metadata?: Record<string, string>;
+}
+/** `POST /v1/profiles` body — create a profile of the caller's app. A name the
+ *  caller's app already holds is refused. */
+export interface CreateProfileRequest extends EnsureProfileRequest {
+    name: string;
+}
+/** `PATCH /v1/profiles/{name}` body — each present field changes one fact of a
+ *  profile the caller's app holds. */
+export interface UpdateProfileRequest {
+    name?: string;
+    default_kind?: string;
+    /** Append a project; a path already listed is left in place. */
+    add_project?: ProfileProject;
+    /** Set the automatic delivery limit for one owner handle; `content` removes it. */
+    set_delivery_limit?: {
+        owner: string;
+        level: ProfileProjectMemory;
+    };
+    /** Remove the project at this path; the directory need not still exist. */
+    remove_project?: string;
+}
+/** `GET /v1/profiles/{name}/env` — stored env var names, never values. */
+export interface ProfileEnvNamesDTO {
+    profile_id: string;
+    names: string[];
+}
+/** `PUT /v1/profiles/{name}/env/{var}` body. */
+export interface SetProfileEnvRequest {
+    value: string;
+}
+/** `PUT` / `DELETE /v1/profiles/{name}/env/{var}` result. */
+export interface ProfileEnvChangeDTO {
+    profile_id: string;
+    /** PUT: the name was newly added. DELETE: a stored value was removed. */
+    changed: boolean;
+}
+/** `PATCH /v1/profiles/{name}/metadata` body. Merges `set` and removes `unset`. */
+export interface UpdateProfileMetadataRequest {
+    set?: Record<string, string>;
+    unset?: string[];
+}
+/** The daemon-owned result of pausing or resuming one profile. */
+export interface ProfilePauseResultDTO {
+    profile_id: string;
+    paused_at: string | null;
+}
+/** `DELETE /v1/profiles/{name}` body. Destructive deletion is never implicit. */
+export interface DeleteProfileRequest {
+    force: boolean;
+    /** Preserve nodes and human history while removing their profile identity. */
+    detach?: boolean;
+    /** The invoking broker, when the request came from a node-owned CLI process. */
+    caller_node_id?: string | null;
+}
+export type DeleteProfileMode = 'deleted' | 'detached';
+/** The completed deletion, or the accepted plan when the invoking node is part of it. */
+export interface DeleteProfileResultDTO {
+    profile_id: string;
+    name: string;
+    mode: DeleteProfileMode;
+    nodes: number;
+    crons: number;
+    tickets: number;
+    reviews: number;
+    default_pins: number;
+    /** True only when crtrd acknowledged the response before tearing down its caller. */
+    accepted?: true;
+    grace_ms?: number;
+}
+/** A profile projection. */
+export interface ProfileDTO {
+    /** Stable profile-directory id (`<slug>-<id>`). */
+    id: string;
+    /** Owning app, including for profiles shared with the caller. */
+    app: string;
+    name: string;
+    projects: ProfileProject[];
+    /** Per-owner delivery caps; empty when the profile sets none. */
+    delivery_limits: DeliveryLimits;
+    /** ISO timestamp when the profile was paused, or null while active. */
+    paused_at: string | null;
+    /** Default node kind when a create omits kind; `general` when absent on the manifest. */
+    default_kind: string;
+    /** Stored profile facts; empty when the manifest carries none. */
+    metadata: Record<string, string>;
+    /** The directory this profile is pinned as default for, if any. */
+    default_dir?: string | null;
+    /** ISO timestamp the profile was created. */
+    created_at: string;
+    /** ISO timestamp of the most recent selection, or null if never selected. */
+    last_used_at: string | null;
+    /** Absolute path of the profile's directory under its app's space (the legacy location of its pre-canvas markdown; the profile's documents live in the canvas). */
+    memory_path: string;
+}

package/dist/api/dto/profiles.js

@@ -0,0 +1,4 @@
+// Profile DTOs (spec §6.6). Profile deletion crosses profile, canvas, cron,
+// inbox, and review state, so every consumer routes it through crtrd.
+/** The disclosure ladder, lowest to highest. Index order is the ordering. */
+export const PROFILE_PROJECT_MEMORY_VALUES = ['none', 'name', 'preview', 'content'];

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

@@ -0,0 +1,104 @@
+export type FaultLink = 'pi→provider' | 'viewer↔broker' | 'relay↔broker' | 'viewer↔crtrd' | 'daemon→node' | 'crtr→pi';
+export type FaultKind = 'rate-limit' | 'overloaded' | 'connection' | 'auth' | 'protocol' | 'context-overflow' | 'other' | 'wedged' | 'model-not-found';
+export interface FaultRetry {
+    disposition: 'auto' | 'manual' | 'fatal';
+    by?: 'sdk' | 'daemon' | 'client';
+    attempt?: number;
+    max?: number;
+    nextAt?: string;
+}
+export interface FaultProviderError {
+    provider: string;
+    model: string;
+    status?: number;
+    code?: string | number;
+    errno?: string;
+    body?: string;
+    causes?: Array<{
+        message?: string;
+        status?: number;
+        code?: string | number;
+        errno?: string;
+        body?: string;
+    }>;
+    ratelimit?: {
+        scope?: string;
+        claim?: string;
+        account?: string;
+        model?: string;
+        headers: Record<string, string>;
+    };
+}
+export interface RecoveryFaultDTO {
+    fault_id: string;
+    link: FaultLink;
+    op: string;
+    kind: FaultKind;
+    retry: FaultRetry;
+    message: string;
+    since: string;
+    operation_id: string;
+    anchor_entry_id?: string;
+    provider_error?: FaultProviderError;
+}
+export interface ExecutionExitDiagnosticDTO {
+    schema: 'crtr.execution-exit-diagnostic/v1';
+    transport_poison: {
+        consecutive_passes: number;
+        routes: string[];
+    };
+}
+export interface BrokerTurnResultDTO {
+    applied: boolean;
+    fault_link: FaultLink | null;
+}
+export interface BrokerTurnRequest {
+    expected_execution_id: string;
+    event: 'started' | 'progress' | 'closed' | 'interrupted' | 'exit-diagnostic';
+    end_reason?: 'settled' | 'teardown-aborted';
+    exit_diagnostic?: ExecutionExitDiagnosticDTO;
+}
+export interface BrokerFaultInputDTO {
+    link: FaultLink;
+    op: string;
+    kind: FaultKind;
+    retry: FaultRetry;
+    message: string;
+    operation_id?: string;
+    since?: string;
+    anchor_entry_id?: string;
+    provider_error?: FaultProviderError;
+}
+export interface BrokerFaultResultDTO {
+    fault: RecoveryFaultDTO | null;
+}
+export interface BrokerFaultRequest {
+    expected_execution_id: string;
+    op: 'record' | 'clear';
+    link?: FaultLink;
+    preserve_episode?: boolean;
+    input?: BrokerFaultInputDTO;
+}
+export interface BrokerProviderRetryResultDTO {
+    applied: boolean;
+    episode: RecoveryStateDTO['episode'];
+}
+export interface BrokerProviderRetryRequest {
+    expected_execution_id: string;
+    op: 'record-pending' | 'admit' | 'reopen' | 'invalidate' | 'clear';
+    session_id: string;
+    fault_id?: string;
+    retry?: FaultRetry;
+    input?: BrokerFaultInputDTO;
+}
+export interface RecoveryStateDTO {
+    fault: RecoveryFaultDTO | null;
+    episode: {
+        state: 'pending' | 'admitted' | 'invalidated';
+        session_id: string | null;
+        fault: RecoveryFaultDTO;
+    } | null;
+}
+export interface NodeFaultClearResultDTO {
+    cleared: boolean;
+}

package/dist/api/dto/recovery.js

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

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

@@ -0,0 +1,93 @@
+import type { IsoTime, NodeIdDTO } from './common.js';
+/** Report kind — `crtr push {update,final}`; legacy `urgent` rows remain readable. */
+export type ReportTierDTO = 'update' | 'urgent' | 'final';
+/** Delivery urgency for an update report's subscriber fan-out. */
+export type ReportDeliveryTierDTO = 'deferred' | 'normal' | 'urgent';
+/** `POST /v1/nodes/{id}/reports` body ({id} = the reporting node).
+ * `tier` is the stored report kind; `delivery_tier` is the optional inbox
+ * delivery urgency for an update's subscriber fan-out. */
+export interface PushReportRequest {
+    tier: ReportTierDTO;
+    delivery_tier?: ReportDeliveryTierDTO;
+    body: string;
+}
+/** Result of a push. `transitioned` is present only for `final`, which drives a
+ *  server-side lifecycle transition. */
+export interface PushReportResultDTO {
+    /** The written report document's ref, `<node-id>/reports/<name>`. */
+    report: string;
+    /** Subscriber node ids that received an inbox entry. */
+    notified: NodeIdDTO[];
+    transitioned?: {
+        from: string;
+        to: string;
+    };
+    /** Present (and true) only for a `final` push that closes the reporting
+     *  node's managed-worktree record without `node worktree close`. An existing
+     *  checkout must be clean with its tip contained in the local base and stays
+     *  pending cleanup; a missing checkout must be proven delivered. Work not
+     *  proven delivered blocks with an `open_managed_worktree` error. */
+    worktree_auto_dropped?: boolean;
+    /** Present only alongside `worktree_auto_dropped`: the closed managed-worktree path; an existing checkout remains until pending cleanup. */
+    worktree_auto_dropped_path?: string;
+}
+/** Why a node declined a structured result. `reason` is one plain sentence
+ *  for a reader; `code` is an opaque token the requester classifies on and
+ *  validates itself — crouter only carries it; `retryable` is the node's
+ *  claim that the same request could succeed later. */
+export interface DeclinedResultDTO {
+    reason: string;
+    code: string;
+    retryable: boolean;
+}
+/** `POST /v1/nodes/{id}/result` body ({id} = the submitting node). Either the
+ *  structured result to validate against the node's pending output schema —
+ *  `value` must be present; any JSON value (including null) is legal input to
+ *  validation — or a decline: `decline` is the reason sentence, `code` the
+ *  requester-classified token, `retryable` the node's retry claim. A decline
+ *  records a `failure` outcome with reason `declined` carrying all three and
+ *  clears the request without validating anything. */
+export type SubmitResultRequest = {
+    value: unknown;
+} | {
+    decline: string;
+    code: string;
+    retryable: boolean;
+};
+/** Result of a structured-result submission (`crtr push result`). Terminal
+ *  mode reuses the final-push machinery, so `transitioned` and the managed-worktree
+ *  closure fields carry the same meaning as on PushReportResultDTO. */
+export interface SubmitResultDTO {
+    /** Which request this answered: `terminal` finished the node; `oneoff` left it working. */
+    mode: 'terminal' | 'oneoff';
+    /** Absolute path of the recorded artifact: context/result.json for an
+     *  answered request, context/declined.json for a declined one. */
+    result_path: string;
+    /** Present only when the request was declined. */
+    declined?: DeclinedResultDTO;
+    /** Ref of the report document pushed alongside the result, `<node-id>/reports/<name>`. */
+    report: string;
+    /** Subscriber node ids that received an inbox entry. */
+    notified: NodeIdDTO[];
+    transitioned?: {
+        from: string;
+        to: string;
+    };
+    worktree_auto_dropped?: boolean;
+    worktree_auto_dropped_path?: string;
+}
+/** `GET /v1/nodes/{id}/reports` query filters. */
+export interface ReportsQuery {
+    tier?: ReportTierDTO;
+    limit?: number;
+}
+/** A single stored report document. */
+export interface ReportDTO {
+    /** Document name under the node, `reports/<compact-ts>-<uuid8>-<kind>`. */
+    name: string;
+    /** Document object id. */
+    id: 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/review-comments.d.ts

@@ -0,0 +1,146 @@
+import type { IsoTime, NodeIdDTO } from './common.js';
+export type ReviewCommentStatusDTO = 'open' | 'resolved' | 'deleted';
+export type ReviewCommentDeliverDTO = 'wake' | 'quiet';
+export type ReviewCommentAnchorStateDTO = 'live' | 'detached';
+/** Caller-supplied source location for a comment or range remap. */
+export interface ReviewCommentAnchorDTO {
+    line: number;
+    end_line: number;
+    col_start?: number;
+    col_end?: number;
+    quote?: string;
+}
+/** Daemon-derived current comment projection. */
+export interface ReviewCommentDTO {
+    comment_id: string;
+    review_id: string;
+    status: ReviewCommentStatusDTO;
+    revision: number;
+    text: string;
+    anchor: ReviewCommentAnchorDTO;
+    anchor_state: ReviewCommentAnchorStateDTO;
+    anchor_line_text: string;
+    anchor_doc_hash: string;
+    author: {
+        kind: 'human' | 'node';
+        node_id?: NodeIdDTO;
+    };
+    updated_by: {
+        kind: 'human' | 'node';
+        node_id?: NodeIdDTO;
+    };
+    created_at: IsoTime;
+    updated_at: IsoTime;
+    resolved_at?: IsoTime;
+    deleted_at?: IsoTime;
+    created_seq: number;
+}
+/** Caller-supplied body for comment creation. `doc_hash` is supplied by a rendered terminal surface; agent CLI creation omits it and the daemon verifies its current coordinate base instead. */
+export interface CreateReviewCommentRequest {
+    text: string;
+    anchor: ReviewCommentAnchorDTO;
+    doc_hash?: string;
+    actor_node_id?: NodeIdDTO | null;
+    deliver?: ReviewCommentDeliverDTO;
+}
+/** Caller-supplied body for comment text changes. */
+export interface EditReviewCommentRequest {
+    text: string;
+    actor_node_id?: NodeIdDTO | null;
+    deliver?: ReviewCommentDeliverDTO;
+    if_revision?: number;
+}
+/** Caller-supplied body for comment state changes. */
+export interface ReviewCommentActionRequest {
+    actor_node_id?: NodeIdDTO | null;
+    deliver?: ReviewCommentDeliverDTO;
+    if_revision?: number;
+}
+/** Daemon-derived best-effort companion-notification result. */
+export interface ReviewCommentDeliveryDTO {
+    attempted: boolean;
+    target_node_id?: NodeIdDTO;
+    status: 'delivered' | 'skipped' | 'failed';
+    via?: 'engine' | 'inbox';
+    woke: boolean;
+    reason?: 'capacity_frozen';
+    error?: string;
+}
+/** Daemon-derived result of one comment mutation. */
+export interface ReviewCommentMutationDTO {
+    comment: ReviewCommentDTO;
+    changed: boolean;
+    delivery?: ReviewCommentDeliveryDTO;
+}
+/** Caller-supplied filter for a review's comment projection. */
+export interface ListReviewCommentsQuery {
+    status?: ReviewCommentStatusDTO | 'all';
+    actor_node_id?: NodeIdDTO | null;
+}
+/** Daemon-derived comment list. */
+export interface ReviewCommentListDTO {
+    review_id: string;
+    comments: ReviewCommentDTO[];
+}
+/** Daemon-derived one-comment projection and audit history. */
+export interface ReviewCommentDetailDTO {
+    comment: ReviewCommentDTO;
+    events: ReviewCommentEventDTO[];
+}
+/** Caller-supplied cursor/limit for the append-only review audit. */
+export interface ReadReviewCommentEventsQuery {
+    since_seq?: number;
+    limit?: number;
+}
+/** Daemon-derived page of append-only review comment events. */
+export interface ReviewCommentEventsDTO {
+    review_id: string;
+    events: ReviewCommentEventDTO[];
+    next_since_seq: number | null;
+}
+/** Daemon-derived append-only comment audit event. */
+export interface ReviewCommentEventDTO {
+    seq: number;
+    review_id: string;
+    comment_id: string;
+    kind: 'created' | 'edited' | 'resolved' | 'reopened' | 'deleted' | 'reanchored' | 'notified' | 'notify_failed';
+    state_change: boolean;
+    revision_after: number | null;
+    actor: {
+        kind: 'human' | 'node' | 'system';
+        node_id?: NodeIdDTO;
+    };
+    at: IsoTime;
+    operation_id: string;
+    payload?: unknown;
+}
+/** Caller-supplied replacement location for one nondeleted comment. */
+export type ReviewCommentRangeEntryDTO = {
+    comment_id: string;
+    anchor: ReviewCommentAnchorDTO;
+} | {
+    comment_id: string;
+    detached: true;
+};
+/** Caller-supplied atomic full-set range remap body. */
+export interface ReviewCommentRangeBatchRequest {
+    from_doc_hash: string;
+    to_doc_hash: string;
+    entries: ReviewCommentRangeEntryDTO[];
+}
+/** Daemon-derived result of an atomic full-set range remap. */
+export interface ReviewCommentRangeBatchResultDTO {
+    review_id: string;
+    anchor_base_sha256: string;
+    updated: number;
+    detached: number;
+    unchanged: number;
+}
+/** Daemon-derived result of forking the review companion onto one comment. */
+export interface ReviewCommentForkDTO {
+    comment_id: string;
+    /** The newborn fork of the review companion. */
+    node_id: NodeIdDTO;
+    /** Where the fork runs, so a caller can place a viewer for it. */
+    cwd: string;
+}

package/dist/api/dto/review-comments.js

@@ -0,0 +1,5 @@
+// Daemon-owned review comment DTOs. These are HTTP wire contracts only.
+//
+// PURITY: imports remain within `src/api/*`; daemon/store types do not cross
+// this boundary.
+export {};