@adhdev/daemon-core 0.9.82-rc.17 → 0.9.82-rc.170

package/dist/providers/spec/types.d.ts

@@ -0,0 +1,212 @@
+export type Size = number | string;
+export interface Section {
+    id: string;
+    from_top?: Size;
+    from_bottom?: Size;
+    until?: {
+        section: string;
+    };
+}
+export interface SectionRegex {
+    section?: string;
+    regex: string;
+    flags?: string;
+}
+export interface SectionPattern {
+    section?: string;
+    pattern: string;
+    flags?: string;
+}
+export interface ModalButtonsRule {
+    section?: string;
+    pattern: string;
+    flags?: string;
+    key_for_index: string;
+    min_count?: number;
+    continuation_lines?: boolean;
+}
+export interface SpecState {
+    id: string;
+    label: string;
+    when: SectionRegex;
+    extract_title?: SectionRegex;
+    modal_buttons?: ModalButtonsRule;
+}
+export type ControlAction = {
+    type: 'send_keys';
+    keys: string;
+} | {
+    type: 'open_picker';
+    trigger_keys: string;
+    wait_for: SectionRegex;
+    extract_choices: SectionPattern;
+    submit_key: string;
+} | {
+    type: 'attach_image';
+    method: 'tempfile_then_keys';
+    keys_template: string;
+};
+export interface Control {
+    id: string;
+    label: string;
+    visible_when_state?: string[];
+    action: ControlAction;
+}
+export interface NotificationRule {
+    id: string;
+    when_state: string;
+    title: string;
+    body?: string;
+}
+export interface DelegateTrigger {
+    id: string;
+    when_state: string;
+    after_duration_ms?: number;
+    task_template: string;
+}
+/**
+ * Native history config — three modes, picked by which fields are present:
+ *
+ *   1. `reader`: built-in reader id (claude-cli / codex-cli / antigravity-cli / hermes-cli).
+ *      Backwards-compatible path used by the four shipped providers.
+ *
+ *   2. `source`: declarative source descriptor. The daemon's spec native-history
+ *      executor reads the on-disk store (jsonl file / sqlite db) directly using
+ *      paths + jsonpath maps from this block. New providers should prefer this
+ *      mode — no daemon changes required.
+ *
+ *   3. `override_path`: relative path to a provider-supplied reader module
+ *      (e.g. "./native_history/index.js"). Escape hatch for formats too
+ *      exotic for the declarative executor. The module must default-export
+ *      a function with the signature
+ *        (input: NativeHistoryInput) => NativeHistoryResult | null
+ *      and runs under provider-script-root sandboxing (same gate as
+ *      scripts.js).
+ *
+ * The three modes are mutually exclusive — set exactly one. Loader rejects
+ * specs that set zero or more than one.
+ */
+export interface NativeHistoryConfig {
+    reader?: 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
+    source?: NativeHistorySource;
+    override_path?: string;
+}
+export type NativeHistorySource = NativeHistoryJsonlSource | NativeHistorySqliteSource;
+/**
+ * JSONL source — each line in the resolved file is one record.
+ *
+ * `path` accepts ~/, environment variables (${HOME}), and a small set of
+ * runtime variables:
+ *   {cwd}              — the session's working directory, raw
+ *   {cwd_dashed}       — cwd with `/` replaced by `-` (claude's per-project key)
+ *   {session_id}       — providerSessionId, when known
+ *   {yyyy} {mm} {dd}   — UTC date components
+ *
+ * When `path` resolves to a directory, the daemon picks the newest file
+ * matching `file_pattern` whose mtime is inside `recent_window_ms` (default
+ * 5min) — prevents the wrong session's transcript from leaking through.
+ */
+export interface NativeHistoryJsonlSource {
+    kind: 'jsonl';
+    path: string;
+    file_pattern?: string;
+    recent_window_ms?: number;
+    session_id_from?: 'filename_uuid' | 'first_record';
+    session_id_path?: string;
+    message_filter?: {
+        where: string;
+    };
+    message_map: NativeHistoryMessageMap;
+}
+/**
+ * SQLite source — provider runs two queries on a read-only handle: one to
+ * pick the session row (`session_query` — first row's first column is the
+ * sessionId), then one to fetch messages (`message_query` — `?` is bound
+ * to the sessionId). Output rows are projected through `message_map`.
+ */
+export interface NativeHistorySqliteSource {
+    kind: 'sqlite';
+    path: string;
+    session_query: string;
+    message_query: string;
+    message_map: NativeHistoryMessageMap;
+}
+/**
+ * Maps a source record (jsonl line object / sqlite row) to a daemon
+ * native-history message. Values are jsonpath-lite strings: `$.foo.bar`
+ * or `$.items[0].text`. Literal strings (no leading `$`) pass through.
+ *
+ * `content_strip` lets a spec drop wrapper tags that the agent injects
+ * into its own transcript (claude's `<local-command-caveat>`, agy's
+ * `<USER_REQUEST>` / `<ADDITIONAL_METADATA>` / `<USER_SETTINGS_CHANGE>`).
+ * Each entry is a tag name; the executor removes `<tag>…</tag>` segments
+ * non-greedily before the value is handed to the dashboard. After all
+ * strips, leading/trailing whitespace is trimmed. If the result is empty
+ * the message is dropped.
+ */
+export interface NativeHistoryMessageMap {
+    role: string;
+    content: string;
+    /**
+     * Tags whose entire `<tag>…</tag>` segment is removed from content.
+     * Use for noise wrappers the agent ships alongside the real message
+     * (claude's `<local-command-caveat>`, agy's `<ADDITIONAL_METADATA>`).
+     */
+    content_strip?: string[];
+    /**
+     * Tags whose open/close markers are removed but inner content is kept.
+     * Use when the *real* user/assistant message is wrapped in a tag
+     * the agent uses for routing (agy wraps user input in `<USER_REQUEST>`).
+     */
+    content_unwrap?: string[];
+    timestamp_ms?: string;
+    kind?: string;
+}
+export interface CliSpec {
+    $schema: 'adhdev:cli/spec@1';
+    id: string;
+    name: string;
+    binary: string;
+    spawn_args?: string[];
+    env?: Record<string, string>;
+    /**
+     * Optional version constraint this spec is authored for, e.g. ">=2.1.0".
+     * Pure metadata used by tooling/UI — the actual version-to-spec match
+     * happens in provider-loader via the manifest's compatibility array.
+     * Spec authors include this so a misrouted spec is easy to spot.
+     */
+    cli_version_range?: string;
+    send_message: {
+        submit_key: string;
+        delay_ms_before_submit?: number;
+        delay_ms_per_char?: number;
+    };
+    layout: {
+        sections: Section[];
+    };
+    states: SpecState[];
+    default_state: string;
+    control_bar?: Control[];
+    notifications?: NotificationRule[];
+    delegate?: DelegateTrigger[];
+    native_history?: NativeHistoryConfig;
+    /**
+     * Per-spec debounce knobs. Defaults are conservative (busy_hold_ms
+     * 6000) and live in SpecDriver. Spec authors override here when a
+     * particular CLI flickers slower/faster than the default.
+     */
+    debounce?: {
+        /** Min time to stay in busy after the evaluator last reported it.
+         *  Absorbs per-frame flicker in TUIs that stream output through
+         *  the same region as the spinner. */
+        busy_hold_ms?: number;
+        /** Min time after start() before a send_message is allowed to
+         *  reach the PTY. Banner paints + auth flows + skill listings
+         *  can keep the agent unable to accept input for several seconds
+         *  even though the idle regex matches a transient empty prompt.
+         *  Send_messages issued before this window are queued and drained
+         *  once the window passes and an idle state has actually been
+         *  observed. */
+        startup_grace_ms?: number;
+    };
+}

package/dist/providers/transcript-v2.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Chat Transcript Contract v2
+ *
+ * First-class message identity, monotonic sequence, strict enums. Designed to
+ * replace the v1 contract (contracts.ts ReadChatResult + types.ts ChatMessage)
+ * during the A2 big-bang. This module defines the contract; it does not yet
+ * change runtime behaviour. v1 keeps working until A2 flips the switch.
+ *
+ * Invariants v2 enforces (and v1 does not):
+ *   1. Every ChatMessageV2 has providerUnitKey, bubbleId, sequence — none optional.
+ *   2. sequence is a monotonic integer per (sessionId, source) tuple. Producers
+ *      never reuse it; consumers MAY assume strict ordering.
+ *   3. providerUnitKey is stable across re-reads: the same logical message
+ *      always yields the same key even if its index shifts or content is
+ *      edited mid-stream. Producers derive it from provider-owned identifiers
+ *      (turn id, native message id), not from content hashes or array index.
+ *   4. timestamp is producer-asserted wall-clock; orderingTimestamp is monotonic
+ *      and used for snapshot diffs. 1ms fallback increments are forbidden — if
+ *      a producer cannot supply a stable monotonic value, the daemon assigns
+ *      sequence at ingest and orderingTimestamp = ingestedAt.
+ *   5. visibility / source / role / kind are strict unions. No `(string & {})`
+ *      escape hatches.
+ *   6. Coverage is exactly one of full/tail/current-turn. Mixing it with
+ *      partialReason or unavailableReason is a contract violation.
+ *   7. workspace / sessionId are explicit on every ReadChatResultV2; the daemon
+ *      no longer infers them from message bodies.
+ */
+import type { MessagePart, ToolCallInfo } from './contracts.js';
+export declare const CHAT_CONTRACT_VERSION_V1: "1.0";
+export declare const CHAT_CONTRACT_VERSION_V2: "2.0";
+export type ChatContractVersion = typeof CHAT_CONTRACT_VERSION_V1 | typeof CHAT_CONTRACT_VERSION_V2;
+export declare const SUPPORTED_CHAT_CONTRACT_VERSIONS: readonly ChatContractVersion[];
+export declare const CHAT_ROLES_V2: readonly ["user", "assistant", "system"];
+export type ChatRoleV2 = typeof CHAT_ROLES_V2[number];
+export declare const CHAT_MESSAGE_KINDS_V2: readonly ["standard", "thought", "tool", "terminal", "system"];
+export type ChatMessageKindV2 = typeof CHAT_MESSAGE_KINDS_V2[number];
+export declare const CHAT_VISIBILITIES_V2: readonly ["user", "debug", "internal", "hidden"];
+export type ChatVisibilityV2 = typeof CHAT_VISIBILITIES_V2[number];
+export declare const CHAT_AUDIENCES_V2: readonly ["chat", "debug", "trace", "internal"];
+export type ChatAudienceV2 = typeof CHAT_AUDIENCES_V2[number];
+export declare const CHAT_SOURCES_V2: readonly ["assistant_text", "tool_call", "terminal_command", "runtime_activity", "runtime_status", "provider_chrome", "control"];
+export type ChatSourceV2 = typeof CHAT_SOURCES_V2[number];
+export declare const CHAT_BUBBLE_STATES_V2: readonly ["draft", "streaming", "final", "removed"];
+export type ChatBubbleStateV2 = typeof CHAT_BUBBLE_STATES_V2[number];
+/**
+ * Stable identity of a single chat message. All fields are required in v2.
+ *
+ * - providerUnitKey: provider-owned canonical id. Must be derivable from
+ *   provider primitives (native message id, turn id, bubble id), NOT from
+ *   array index or content hash. Stable across re-reads of the same logical
+ *   message even if neighbours change.
+ * - bubbleId: dashboard-owned bubble identity. May equal providerUnitKey when
+ *   the provider already exposes a bubble-grained id; otherwise daemon
+ *   derives it deterministically from providerUnitKey (e.g. `bubble:${key}`).
+ * - sequence: monotonic integer per (sessionId, source). Strictly increasing
+ *   over the lifetime of the session. Used for snapshot diffs and dedup.
+ * - turnKey: stable identifier for the conversation turn this message belongs
+ *   to. Required so consumers can group messages without re-deriving turns.
+ */
+export interface MessageIdentityV2 {
+    providerUnitKey: string;
+    bubbleId: string;
+    sequence: number;
+    turnKey: string;
+}
+/**
+ * Producer-asserted wall-clock time (ms since epoch). Forward jumps are
+ * permitted; consumers MUST NOT rely on this for ordering.
+ */
+export type ChatTimestampMs = number;
+/**
+ * Monotonic ordering value (ms since epoch, but assigned by the daemon at
+ * ingest to guarantee monotonicity even if the producer's wall clock skews).
+ * Used by snapshot diffs in place of timestamp.
+ */
+export type ChatOrderingTimestampMs = number;
+export interface ChatMessageV2 extends MessageIdentityV2 {
+    role: ChatRoleV2;
+    kind: ChatMessageKindV2;
+    content: string | MessagePart[];
+    bubbleState: ChatBubbleStateV2;
+    timestamp: ChatTimestampMs;
+    orderingTimestamp: ChatOrderingTimestampMs;
+    visibility: ChatVisibilityV2;
+    audience: ChatAudienceV2;
+    source: ChatSourceV2;
+    /** Sender display name (for shared sessions). Empty string when unused. */
+    senderName: string;
+    /** Tool calls associated with this message. Empty array when none. */
+    toolCalls: ToolCallInfo[];
+    /** Producer-defined metadata. Daemon never inspects this except for passthrough. */
+    meta: Readonly<Record<string, unknown>>;
+}
+export interface WorkspaceContextV2 {
+    /** Absolute realpath of the workspace the session is reading from. */
+    workspacePath: string;
+    /** Workspace the session was intended to operate on (may differ during cross-workspace ops). */
+    intendedWorkspacePath: string;
+}
+export interface SessionContextV2 {
+    /** Provider-owned session id (e.g. claude.jsonl uuid, codex session_meta.id). */
+    providerSessionId: string;
+    /** Optional daemon-side history alias used to disambiguate within a workspace. */
+    historySessionId?: string;
+}
+/**
+ * v1 allowed `coverage='full'` to coexist with `partialReason`/`unavailableReason`,
+ * which is a contract lie. v2 makes the three states mutually exclusive.
+ */
+export type CoverageHintV2 = {
+    kind: 'full';
+} | {
+    kind: 'tail';
+    tailMessageCount: number;
+} | {
+    kind: 'current-turn';
+    turnKey: string;
+} | {
+    kind: 'partial';
+    partialReason: string;
+} | {
+    kind: 'unavailable';
+    unavailableReason: string;
+};
+export type CanonicalHistoryModeV2 = 'native-source' | 'disabled' | 'materialized-mirror';
+export interface CanonicalHistoryDeclarationV2 {
+    contractVersion: ChatContractVersion;
+    format: string;
+    mode: CanonicalHistoryModeV2;
+    watchPath?: string;
+    scripts: {
+        readSession: string;
+        listSessions: string;
+    };
+}
+export type ReadChatStatusV2 = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'panel_hidden' | 'streaming';
+export type ReadChatTurnStatusV2 = 'open' | 'waiting_approval' | 'complete' | 'error';
+export interface ReadChatResultV2 {
+    contractVersion: typeof CHAT_CONTRACT_VERSION_V2;
+    workspace: WorkspaceContextV2;
+    session: SessionContextV2;
+    coverage: CoverageHintV2;
+    status: ReadChatStatusV2;
+    messages: ChatMessageV2[];
+    currentTurnId: string;
+    turnStatus: ReadChatTurnStatusV2;
+    transcriptAuthority: 'provider' | 'daemon';
+}
+export declare class ChatContractViolationError extends Error {
+    readonly violationPath: string;
+    readonly contractVersion: ChatContractVersion;
+    constructor(contractVersion: ChatContractVersion, violationPath: string, detail: string);
+}
+/**
+ * Validate a v2 read_chat payload. Throws ChatContractViolationError on the
+ * first violation. v2 invariants beyond per-field checks:
+ *   - messages[*].sequence strictly increasing
+ *   - messages[*].orderingTimestamp monotonic non-decreasing
+ *   - coverage union is well-formed
+ */
+export declare function assertReadChatResultV2Payload(raw: unknown): ReadChatResultV2;
+export declare function isSupportedChatContractVersion(value: unknown): value is ChatContractVersion;
+/**
+ * Read a provider's declared chat contract version from its parsed
+ * provider.json `canonicalHistory.contractVersion` field.
+ *
+ * - Absent or unrecognized → treated as v1 (legacy behaviour preserved during
+ *   the A1 transition). A2 will tighten this to reject unsupported versions
+ *   at provider load time.
+ * - Present and supported → returned as-is.
+ *
+ * The returned version drives which validator (assertReadChatResultV2Payload
+ * vs the legacy validateReadChatResultPayload) processes the provider's
+ * read_chat output.
+ */
+export declare function readDeclaredChatContractVersion(canonicalHistory: unknown): ChatContractVersion;

package/dist/providers/types/interactive-prompt.d.ts

@@ -0,0 +1,48 @@
+export interface InteractivePrompt {
+    promptId: string;
+    origin: 'cli' | 'mcp' | 'agent';
+    providerType: string;
+    createdAt: number;
+    questions: InteractiveQuestion[];
+}
+export interface InteractiveQuestion {
+    questionId: string;
+    question: string;
+    header?: string;
+    multiSelect: boolean;
+    options: InteractiveOption[];
+    allowFreeform?: boolean;
+}
+export interface InteractiveOption {
+    label: string;
+    description?: string;
+    preview?: string;
+}
+export interface InteractivePromptResponse {
+    promptId: string;
+    answers: Record<string, InteractiveAnswer>;
+}
+export interface InteractiveAnswer {
+    selectedLabels: string[];
+    freeformText?: string;
+}
+export declare function normalizeInteractivePrompt(raw: unknown): InteractivePrompt | null;
+export declare function normalizeInteractivePromptResponse(raw: unknown): InteractivePromptResponse;
+export declare function buildClaudeInteractiveToolResult(response: InteractivePromptResponse): string;
+export interface ClaudeInteractiveTuiPage {
+    screenText: string;
+    header?: string;
+}
+export declare function detectClaudeAskUserQuestionPromptFromTuiPages(pages: ClaudeInteractiveTuiPage[], options: {
+    promptId: string;
+    providerType?: string;
+    createdAt?: number;
+}): InteractivePrompt | null;
+export declare function buildClaudeInteractiveTuiAnswerSteps(prompt: InteractivePrompt, response: InteractivePromptResponse): string[];
+export declare function interactivePromptFromClaudeAskUserQuestion(input: unknown, options: {
+    promptId: string;
+    providerType: string;
+    createdAt?: number;
+    origin?: InteractivePrompt['origin'];
+}): InteractivePrompt | null;
+export declare function detectClaudeAskUserQuestionPromptFromJson(value: unknown, providerType?: string): InteractivePrompt | null;

package/dist/repo-mesh-types.d.ts

@@ -19,10 +19,37 @@ export interface RepoMesh {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     projectContext: ProjectContextSnapshot;
     nodes: RepoMeshNode[];
     status: 'active' | 'archived' | 'deleted';
 }
+export type RepoMeshDaemonRole = 'host' | 'member';
+export interface RepoMeshHostPairingMetadata {
+    status: 'not_configured' | 'pairing' | 'paired' | 'rejected' | 'revoked';
+    tokenId?: string;
+    joinedAt?: string;
+    lastPairedAt?: string;
+    lastRejectedAt?: string;
+    expiresAt?: string;
+}
+export interface RepoMeshHostMetadata {
+    /** Local daemon role for this mesh. Missing metadata defaults to host for standalone compatibility. */
+    role: RepoMeshDaemonRole;
+    /** Daemon that owns mesh truth/status/git/queue/session/ledger/coordinator ownership. */
+    hostDaemonId?: string;
+    /** Mesh node that represents the host daemon, when known. */
+    hostNodeId?: string;
+    /** Future standalone manual pairing endpoint entered by member daemons. */
+    hostAddress?: string;
+    /** Redacted pairing state only; raw join tokens must not be persisted here. */
+    pairing?: RepoMeshHostPairingMetadata;
+}
+export interface RepoMeshHostStatus extends RepoMeshHostMetadata {
+    canOwnCoordinator: boolean;
+    canOwnQueue: boolean;
+    defaulted: boolean;
+}
 export interface RepoMeshNode {
     id: string;
     daemonId: string;
@@ -37,6 +64,7 @@ export interface RepoMeshNode {
     effectiveCapabilities: RepoMeshNodeCapabilities;
     policy: RepoMeshNodePolicy;
     health: RepoMeshNodeHealth;
+    role?: RepoMeshDaemonRole;
     status: 'enabled' | 'disabled' | 'removed';
 }
 export type RepoMeshNodeHealth = 'online' | 'offline' | 'degraded' | 'dirty' | 'wrong_branch' | 'unknown';
@@ -46,6 +74,13 @@ export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
     requireApprovalForPush: boolean;
+    /**
+     * Narrow Refinery opt-in: when validation and patch-equivalence have passed,
+     * allow Refinery to publish submodule gitlink commits to each submodule's
+     * configured remote main branch with a non-force push, then verify reachability.
+     * Defaults to false; root branch pushes/merges are not affected.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     requireApprovalForDestructiveGit: boolean;
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
@@ -167,7 +202,28 @@ export interface RepoMeshCoordinatorConfig {
     providerType?: string;
     /** Preferred node to run coordinator on (null = auto) */
     preferredNodeId?: string;
-    /** Additional system prompt context for coordinator */
+    /**
+     * Full mesh-level override for the coordinator system prompt. When set,
+     * replaces the daemon's rendered default and any user-file override
+     * (~/.adhdev/coordinator-prompts/<cli>.md). The per-launch
+     * extraSystemPrompt still composes on top — it always lands last as
+     * Additional Context. Supports the same {{placeholders}} the daemon's
+     * default template uses ({{meshName}}, {{repo}}, {{nodes}}, …).
+     */
+    systemPromptOverride?: string;
+    /**
+     * Mesh-level append. Composes after whichever base prompt won
+     * (override → user-file override → daemon default). Use this when you
+     * want extra rules for THIS mesh but otherwise the standard prompt is
+     * fine. Stacks with the user-file append (`<cli>.append.md`) — both
+     * apply if both are set.
+     */
+    systemPromptAppend?: string;
+    /**
+     * @deprecated Use systemPromptAppend. Kept as a fallback alias so
+     * existing meshes.json files keep working without a migration step;
+     * the daemon prefers systemPromptAppend when both are present.
+     */
     systemPromptSuffix?: string;
 }
 /**
@@ -185,6 +241,7 @@ export interface LocalMeshEntry {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     nodes: LocalMeshNodeEntry[];
     createdAt: string;
     updatedAt: string;
@@ -198,14 +255,38 @@ export interface LocalMeshNodeEntry {
     machineId?: string;
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
+    /**
+     * Per-node instruction surfaced in the coordinator prompt so the LLM
+     * knows what each node is for (e.g. "this is the staging mirror — run
+     * only smoke tests here", or "use opus on this node, sonnet elsewhere").
+     * Empty/missing: omitted silently from the rendered prompt, no rule
+     * line about it gets added. The coordinator forwards/honors it when
+     * delegating; we don't enforce it at the daemon level.
+     */
+    systemPrompt?: string;
     /** For single-machine mesh: same daemon, different worktree */
     isLocalWorktree?: boolean;
     /** Branch this worktree tracks (set when created via clone_mesh_node) */
     worktreeBranch?: string;
     /** Node ID this worktree was cloned from */
     clonedFromNodeId?: string;
+    /** Repo-local preparation result for ADHDev-created worktree nodes. */
+    worktreeBootstrap?: {
+        status: 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
+        required?: boolean;
+        configSource?: string;
+        configSourceType?: string;
+        startedAt?: string;
+        completedAt?: string;
+        lastCommand?: string;
+        exitCode?: number | null;
+        error?: string;
+        commandsRun?: Array<Record<string, unknown>>;
+        staleInputs?: string[];
+    };
     /** Optional associated/external repos configured as node metadata. */
     relatedRepos?: RepoMeshRelatedRepo[];
+    role?: RepoMeshDaemonRole;
 }
 export interface RepoMeshStatus {
     meshId: string;
@@ -213,6 +294,7 @@ export interface RepoMeshStatus {
     repoIdentity: string;
     defaultBranch?: string;
     refreshedAt: string;
+    meshHost?: RepoMeshHostStatus;
     nodes: RepoMeshNodeStatus[];
     queue?: RepoMeshQueueStatus;
     ledger?: RepoMeshLedgerStatus;
@@ -249,16 +331,28 @@ export interface RepoMeshNodeStatus {
     repoRoot?: string;
     daemonId?: string;
     machineId?: string;
+    role?: RepoMeshDaemonRole;
     machineStatus?: string;
     isLocalWorktree?: boolean;
     worktreeBranch?: string;
+    /** Mirrored from LocalMeshNodeEntry.systemPrompt for coordinator-prompt rendering. */
+    systemPrompt?: string;
     health: RepoMeshNodeHealth;
     git?: GitRepoStatus;
+    /**
+     * True when the selected coordinator has evidence that a peer git probe is still
+     * in flight or just timed out during initial mesh handshake, so callers should
+     * treat missing git data as pending instead of authoritative absence.
+     */
+    gitProbePending?: boolean;
     providers: string[];
     activeSessions: string[];
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];
     launchReady?: boolean;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    launchBlockedReason?: string;
+    launchBlockedMessage?: string;
     lastSeenAt?: string;
     updatedAt?: string;
     connection?: RepoMeshPeerConnectionStatus;
@@ -346,3 +440,8 @@ export interface RepoMeshLedgerStatus {
     entries: RepoMeshLedgerEntryStatus[];
     summary: RepoMeshLedgerSummaryStatus;
 }
+export interface MeshAsyncJobLifecycle {
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+}

package/dist/sessions/registry.d.ts

@@ -7,6 +7,9 @@ export interface SessionRuntimeTarget {
     cdpManagerKey?: string;
     adapterKey?: string;
     instanceKey?: string;
+    /** Wall clock at register time. native-history readers use it as a
+     *  cutoff so a fresh session can't show records from a prior one. */
+    spawnedAtMs?: number;
 }
 export declare class SessionRegistry {
     private readonly bySessionId;