@adhdev/mesh-shared 1.0.60-rc.4 → 1.0.60-rc.41

package/dist/turn-ipc.d.ts

@@ -0,0 +1,974 @@
+/**
+ * turn-ipc — typed IPC command contracts for the six commands that replace
+ * mcp-server's direct `mesh-runtime.db` access (design §5 C2 "MCP server").
+ *
+ * Wiring-unification Phase C, workstream C-W6
+ * (docs/design/2026-09-23-wiring-unification.md §5 C2/C3, C9 row C-W6).
+ *
+ * WHY THIS FILE EXISTS
+ * ---------------------
+ * mcp-server is a second, in-process writer of `mesh-runtime.db` (~45-69
+ * direct-mutation call sites, ~54 reads, per the C-W6 brief). C2 moves every
+ * one of those call sites behind IPC, executed in the daemon that owns the
+ * turn ledger and the seqscribe node, so mcp-server never opens the SQLite
+ * file itself. This file is the WIRE CONTRACT for that IPC surface — request/
+ * response shapes, closed enums, runtime decoders — shared by the daemon-core
+ * command handlers (added with C-W6 proper; NOT this file) and the mcp-server
+ * client (`mcp-server/src/ipc/turn-commands.ts`, this workstream).
+ *
+ * The six commands (§5 C2):
+ *   - turn_observe     — submit one TurnEvidence; returns the reducer verdict.
+ *   - mesh_record      — append a content-free scalar record (`mesh.record`
+ *                         topic entry), replacing `appendLedgerEntry`.
+ *   - turn_cancel       — cancel an attempt (`cancel` evidence, source `mcp_probe`
+ *                         or `operator`).
+ *   - operator_status   — record a fire-and-forget operator/tool-call status
+ *                         (`operator_status` evidence + the former
+ *                         `recordMeshCoordinatorToolCall` log write).
+ *   - turn_query        — read attempt/event rows (own or fleet scope).
+ *   - mesh_index_query  — read `mesh_topic_index` rows (fleet-wide, replacing
+ *                         the in-memory read model / parity reads).
+ *
+ * CONTENT BOUNDARY
+ * -----------------
+ * Every request/response field is an identifier, a closed enum, a boolean, a
+ * counter or a timestamp. `turn_observe` carries a `TurnEvidence`, which is
+ * content-free by construction (`turn-evidence.ts`). `mesh_record` carries a
+ * `ProjectedScalars` payload restricted to the SAME allow-list keys
+ * `seqscribe/mesh-event-projection.ts` already reviews and ships
+ * (`PROJECTED_PAYLOAD_KEYS`, 35 keys) — this file pins a STRUCTURAL COPY of
+ * that key list (`MESH_RECORD_PAYLOAD_KEYS`) so mesh-shared does not import
+ * daemon-core (leaf constraint), with a test asserting the two lists agree.
+ * Summaries, report bodies, progress notes and modal text never travel in any
+ * of these payloads — they go to the content-class `mesh.<id>.handoff` topic
+ * and are referenced by `SummaryRef {topic, writer, seq}` (already declared
+ * in `./turn-evidence.ts`).
+ *
+ * VERSIONING
+ * -----------
+ * Every request carries `v: 1` so a future incompatible change can be
+ * detected by the responder before it tries to interpret the args.
+ */
+import { type ProjectedScalars, type TurnAttemptRef, type TurnEvidence, type TurnEvidenceKind, type TurnOutcome, type TurnReason } from './turn-evidence';
+/** Every request in this file is versioned so a responder can reject a shape it predates. */
+export declare const TURN_IPC_PROTOCOL_VERSION: 1;
+/**
+ * Closed error-code union every command response may carry instead of (or in
+ * addition to, for the client-side wrapper) a result.
+ *
+ *   daemon_required      — no daemon reachable (no IPC/local transport
+ *                           connection could be established). Distinct from
+ *                           every other failure: it means "there is nobody to
+ *                           ask", not "the ask failed."
+ *   turn_ledger_unavailable — a daemon answered but its turn ledger is not
+ *                           armed yet (mid-boot, mid-migration).
+ *   ledger_not_owner     — the daemon that answered does not own the
+ *                           attempt/mesh addressed by the request (routing
+ *                           mistake, or the owner changed after a reclaim).
+ */
+export declare const TURN_IPC_ERROR_CODES: readonly ["daemon_required", "turn_ledger_unavailable", "ledger_not_owner"];
+export type TurnIpcErrorCode = typeof TURN_IPC_ERROR_CODES[number];
+export declare const isTurnIpcErrorCode: (value: unknown) => value is "daemon_required" | "turn_ledger_unavailable" | "ledger_not_owner";
+/** Structured failure shape a responder returns instead of a result. Never thrown across the wire — the client maps it to a typed error (see mcp-server/src/ipc/turn-commands.ts). */
+export interface TurnIpcError {
+    code: TurnIpcErrorCode;
+    /** Short machine-oriented detail, e.g. which daemon was expected. Never free text describing content. */
+    detail?: string;
+}
+export declare function isTurnIpcError(value: unknown): value is TurnIpcError;
+/** Reducer verdict, mirrored from the C1 reducer's `reduce()` return shape. */
+export declare const TURN_OBSERVE_VERDICTS: readonly ["applied", "recorded", "rejected"];
+export type TurnObserveVerdict = typeof TURN_OBSERVE_VERDICTS[number];
+export declare const isTurnObserveVerdict: (value: unknown) => value is "rejected" | "applied" | "recorded";
+export interface TurnObserveRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    evidence: TurnEvidence;
+}
+export interface TurnObserveResponse {
+    verdict: TurnObserveVerdict;
+    attemptRef: TurnAttemptRef;
+    /** Present only when the evidence committed the attempt (verdict 'applied' + a terminal-class kind). */
+    outcome?: TurnOutcome;
+}
+export declare function isTurnObserveRequest(value: unknown): value is TurnObserveRequest;
+export declare function decodeTurnObserveRequest(value: unknown): TurnObserveRequest | null;
+export declare function isTurnObserveResponse(value: unknown): value is TurnObserveResponse;
+export declare function decodeTurnObserveResponse(value: unknown): TurnObserveResponse | null;
+/**
+ * Structural pin of `seqscribe/mesh-event-projection.ts` `PROJECTED_PAYLOAD_KEYS`
+ * (daemon-core; this leaf cannot import it). A test in this package's test
+ * suite AND a daemon-core test each assert their list equals this one — see
+ * `mesh-shared/test/turn-ipc.test.ts` and the C-W6 report's break-once table.
+ * Adding a key here is the SAME assertion as adding it there: non-content
+ * (identifier, enum, boolean, or counter), never free text.
+ */
+export declare const MESH_RECORD_PAYLOAD_KEYS: readonly ["taskId", "deliveryId", "attemptId", "missionId", "checkpointId", "promptId", "providerSessionId", "targetNoteId", "nodeId", "sessionId", "providerType", "transport", "attemptedSessionId", "holderSessionId", "reason", "status", "outcome", "terminalKind", "event", "source", "intentionalStopReason", "retryable", "rebound", "forced", "fallback", "membershipRemoved", "requestedForce", "removedByRemoteDaemon", "completedViaReady", "intentional", "weak", "attempt", "attemptCount", "count"];
+export type MeshRecordPayloadKey = typeof MESH_RECORD_PAYLOAD_KEYS[number];
+/** Maximum length of any string value in a `mesh_record` payload (mirrors `MAX_PROJECTED_STRING`). */
+export declare const MAX_MESH_RECORD_STRING = 200;
+export interface MeshRecordRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** The original ledger `kind` string (daemon-core `MeshLedgerKind`; mesh-shared cannot import that union, so it is an identifier here). */
+    ledgerKind: string;
+    nodeId?: string;
+    sessionId?: string;
+    taskId?: string;
+    /** Restricted to `MESH_RECORD_PAYLOAD_KEYS` — an unknown key is a decode failure, not a silently dropped field. */
+    payload: ProjectedScalars;
+}
+export interface MeshRecordResponse {
+    /** `mesh.<id>.events` append coordinates, for callers that need to reference the entry (e.g. a `ref`'d handoff). */
+    eventId: string;
+    seq: number;
+}
+/** Every payload key must be a member of `MESH_RECORD_PAYLOAD_KEYS` — the allow-list boundary at the wire. */
+export declare function isMeshRecordPayload(value: unknown): value is ProjectedScalars;
+export declare function isMeshRecordRequest(value: unknown): value is MeshRecordRequest;
+export declare function decodeMeshRecordRequest(value: unknown): MeshRecordRequest | null;
+export declare function isMeshRecordResponse(value: unknown): value is MeshRecordResponse;
+export declare function decodeMeshRecordResponse(value: unknown): MeshRecordResponse | null;
+export interface TurnCancelRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    /** Exactly one of the two must be present — the decoder rejects both-or-neither. */
+    attemptId?: string;
+    taskId?: string;
+    reason: TurnReason;
+}
+export interface TurnCancelResponse {
+    attemptRef: TurnAttemptRef;
+    verdict: TurnObserveVerdict;
+}
+export declare function isTurnCancelRequest(value: unknown): value is TurnCancelRequest;
+export declare function decodeTurnCancelRequest(value: unknown): TurnCancelRequest | null;
+export declare function isTurnCancelResponse(value: unknown): value is TurnCancelResponse;
+export declare function decodeTurnCancelResponse(value: unknown): TurnCancelResponse | null;
+/**
+ * Fire-and-forget operator/tool-call status record — replaces
+ * `recordMeshCoordinatorToolCall` (10 sites, `mesh_tool_call_log`) and doubles
+ * as the `operator_status` evidence kind's wire shape.
+ *
+ * NAMING NOTE (flagged for the C-W6 implementer, see report §"mismatch"):
+ * the C-W6 brief's DELIVERABLES describes this request as
+ * `{taskId, status: MeshTaskStatus, reason}`, but C1's `operator_status`
+ * evidence kind (`turn-evidence.ts` `OPERATOR_STATUSES`) is the closed
+ * 2-value set `'completed' | 'failed'` — a verdict on an operator ACTION, not
+ * a `MeshTaskStatus` (5-value queue-row status: pending/assigned/completed/
+ * failed/cancelled). This contract follows `turn-evidence.ts` because that is
+ * what the C1 reducer actually consumes for this evidence kind; using the
+ * 5-value `MeshTaskStatus` here would let this request carry `pending` or
+ * `assigned`, which the reducer has no transition for.
+ */
+export declare const OPERATOR_STATUS_VALUES: readonly ["completed", "failed"];
+export type OperatorStatusValue = typeof OPERATOR_STATUS_VALUES[number];
+export declare const isOperatorStatusValue: (value: unknown) => value is "failed" | "completed";
+export declare const OPERATOR_STATUS_REASON_VALUES: readonly ["operator_update", "refine_terminal", "validation_terminal"];
+export type OperatorStatusReasonValue = typeof OPERATOR_STATUS_REASON_VALUES[number];
+export declare const isOperatorStatusReasonValue: (value: unknown) => value is "operator_update" | "refine_terminal" | "validation_terminal";
+export interface OperatorStatusRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    taskId: string;
+    status: OperatorStatusValue;
+    reason: OperatorStatusReasonValue;
+}
+/** Acknowledgement only — this command is fire-and-forget by design (the daemon owns rate-limiting the underlying log). */
+export interface OperatorStatusResponse {
+    accepted: true;
+}
+export declare function isOperatorStatusRequest(value: unknown): value is OperatorStatusRequest;
+export declare function decodeOperatorStatusRequest(value: unknown): OperatorStatusRequest | null;
+export declare function isOperatorStatusResponse(value: unknown): value is OperatorStatusResponse;
+export declare function decodeOperatorStatusResponse(value: unknown): OperatorStatusResponse | null;
+/** Row shape returned by `turn_query` — scalar projection of a `turn_attempts` row (C3 schema), never `data_json`/`payload_json` content. */
+export interface TurnQueryAttemptRow {
+    attemptId: string;
+    generation: number;
+    meshId?: string;
+    taskId?: string;
+    sessionId: string;
+    nodeId?: string;
+    providerType?: string;
+    state: string;
+    terminalOutcome?: TurnOutcome;
+    terminalReason?: TurnReason;
+    acceptedAt: number;
+    terminalAt?: number;
+}
+/** Row shape returned by `turn_query` for the event stream — scalar projection of a `turn_events` row, `payload_json` NEVER included. */
+export interface TurnQueryEventRow {
+    eventId: string;
+    attemptId?: string;
+    generation?: number;
+    sessionId: string;
+    kind: TurnEvidenceKind;
+    source: string;
+    verdict: TurnObserveVerdict | 'forwarded';
+    atMs: number;
+}
+export interface TurnQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    taskId?: string;
+    attemptId?: string;
+    sessionId?: string;
+    state?: string;
+    since?: number;
+    tail?: number;
+}
+export interface TurnQueryResponse {
+    attempts: readonly TurnQueryAttemptRow[];
+    events: readonly TurnQueryEventRow[];
+    /** C7-5: set while `mesh.<id>.events` replication is behind for this mesh — the caller must not treat a fleet-scope answer as complete. */
+    replicationPending?: boolean;
+}
+export declare function isTurnQueryRequest(value: unknown): value is TurnQueryRequest;
+export declare function decodeTurnQueryRequest(value: unknown): TurnQueryRequest | null;
+export declare function isTurnQueryResponse(value: unknown): value is TurnQueryResponse;
+export declare function decodeTurnQueryResponse(value: unknown): TurnQueryResponse | null;
+export declare const MESH_INDEX_QUERY_WRITER_SCOPES: readonly ["own", "fleet"];
+export type MeshIndexQueryWriterScope = typeof MESH_INDEX_QUERY_WRITER_SCOPES[number];
+export declare const isMeshIndexQueryWriterScope: (value: unknown) => value is "own" | "fleet";
+export interface MeshIndexQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    ledgerKind?: string;
+    sessionId?: string;
+    taskId?: string;
+    writer?: MeshIndexQueryWriterScope;
+    since?: number;
+    tail?: number;
+}
+/** Row shape returned by `mesh_index_query` — a `mesh_topic_index` row (C3 schema). */
+export interface MeshTopicIndexRow {
+    writer: string;
+    seq: number;
+    meshId: string;
+    eventId: string;
+    kind: string;
+    ledgerKind?: string;
+    taskId?: string;
+    sessionId?: string;
+    nodeId?: string;
+    atMs: number;
+    payload: ProjectedScalars;
+}
+export interface MeshIndexQueryResponse {
+    rows: readonly MeshTopicIndexRow[];
+    /** C7-5: true while `mesh.<id>.events` replication is behind for this mesh. */
+    replicationPending?: boolean;
+}
+export declare function isMeshIndexQueryRequest(value: unknown): value is MeshIndexQueryRequest;
+export declare function decodeMeshIndexQueryRequest(value: unknown): MeshIndexQueryRequest | null;
+export declare function isMeshIndexQueryResponse(value: unknown): value is MeshIndexQueryResponse;
+export declare function decodeMeshIndexQueryResponse(value: unknown): MeshIndexQueryResponse | null;
+export declare const MESH_MISSION_STATUSES: readonly ["active", "paused", "completed", "abandoned"];
+export type MeshMissionStatusValue = typeof MESH_MISSION_STATUSES[number];
+export declare const isMeshMissionStatusValue: (value: unknown) => value is "active" | "completed" | "paused" | "abandoned";
+export declare const MESH_MISSION_SOURCES: readonly ["magi", "coordinator"];
+export type MeshMissionSourceValue = typeof MESH_MISSION_SOURCES[number];
+export declare const isMeshMissionSourceValue: (value: unknown) => value is "coordinator" | "magi";
+export interface MissionBriefWire {
+    goal: string;
+    constraints?: readonly string[];
+    doneCriteria?: readonly string[];
+    handoffNotes?: readonly string[];
+    ownedPaths?: readonly string[];
+}
+export interface MissionUpsertRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** Omitted = create a new mission; present = update (must resolve to an existing mission — see mesh-missions.ts MISSION-UPSERT-SILENT-CREATE). */
+    id?: string;
+    title: string;
+    /** Free text — see file-header note on why this is fine over local IPC. */
+    goal?: string;
+    status?: MeshMissionStatusValue;
+    source?: MeshMissionSourceValue;
+    /**
+     * H2: `undefined` = do not touch the stored brief. `null` = explicitly clear it.
+     * A present object with no usable `goal` is treated by the daemon's own
+     * `normalizeMissionBrief` as "no brief" (see mesh-missions.ts upsertMeshMission) —
+     * this wire guard only checks SHAPE, not that decision.
+     */
+    brief?: MissionBriefWire | null;
+}
+export interface MeshMissionRecordWire {
+    id: string;
+    meshId: string;
+    title: string;
+    goal: string;
+    status: MeshMissionStatusValue;
+    source?: MeshMissionSourceValue;
+    /** H2: absent = no brief attached to this mission. */
+    brief?: MissionBriefWire;
+}
+export interface MissionUpsertResponse {
+    mission: MeshMissionRecordWire;
+}
+export declare function isMissionUpsertRequest(value: unknown): value is MissionUpsertRequest;
+export declare function decodeMissionUpsertRequest(value: unknown): MissionUpsertRequest | null;
+export declare function isMissionUpsertResponse(value: unknown): value is MissionUpsertResponse;
+export declare function decodeMissionUpsertResponse(value: unknown): MissionUpsertResponse | null;
+export interface MissionQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** Omitted = every status. */
+    statuses?: readonly MeshMissionStatusValue[];
+    /** Single-mission lookup (mesh-missions.ts `getMeshMission`'s shape) — mutually exclusive with `statuses`. */
+    id?: string;
+}
+export interface MissionQueryResponse {
+    missions: readonly MeshMissionRecordWire[];
+}
+export declare function isMissionQueryRequest(value: unknown): value is MissionQueryRequest;
+export declare function decodeMissionQueryRequest(value: unknown): MissionQueryRequest | null;
+export declare function isMissionQueryResponse(value: unknown): value is MissionQueryResponse;
+export declare function decodeMissionQueryResponse(value: unknown): MissionQueryResponse | null;
+export interface MissionListQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    statuses?: readonly MeshMissionStatusValue[];
+    verbose?: boolean;
+    includeMagi?: boolean;
+    withStats?: boolean;
+    limit?: number;
+    historyIdLimit?: number;
+}
+export interface MeshMissionTaskAggregateWire {
+    total: number;
+    pending: number;
+    assigned: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    blocked: number;
+    lastActivityAt: string | null;
+}
+export interface MeshMissionStatsWire {
+    missionId: string;
+    taskCount: number;
+    completed: number;
+    failed: number;
+    totalDurationMs: number;
+    wallClockMs: number | null;
+    retries: number;
+    incompleteTaskIds: readonly string[];
+}
+/** Verbose (full-goal) mission row. `goal` present, `goalPreview`/`goalTruncated` absent. */
+export interface MissionListSummaryVerboseWire {
+    id: string;
+    meshId: string;
+    title: string;
+    goal: string;
+    status: MeshMissionStatusValue;
+    source?: MeshMissionSourceValue;
+    tasks: MeshMissionTaskAggregateWire;
+    stats?: MeshMissionStatsWire;
+    /** H2: absent = no brief attached. */
+    brief?: MissionBriefWire;
+}
+/** Compact (default) mission row. `goalPreview`/`goalTruncated` present, `goal` absent. */
+export interface MissionListSummarySlimWire {
+    id: string;
+    meshId: string;
+    title: string;
+    goalPreview: string;
+    goalTruncated: boolean;
+    status: MeshMissionStatusValue;
+    source?: MeshMissionSourceValue;
+    tasks: MeshMissionTaskAggregateWire;
+    stats?: MeshMissionStatsWire;
+    /** H2: absent = no brief attached. */
+    brief?: MissionBriefWire;
+}
+export type MissionListSummaryWire = MissionListSummaryVerboseWire | MissionListSummarySlimWire;
+export interface MeshMissionHistoryFoldWire {
+    count: number;
+    byStatus: Record<string, number>;
+    missionIds: readonly string[];
+    note: string;
+}
+export interface MissionListQueryResponse {
+    missions: readonly MissionListSummaryWire[];
+    historyFold: MeshMissionHistoryFoldWire | null;
+    truncated: boolean;
+    matched: number;
+    overflowIds?: readonly string[];
+}
+export declare function isMissionListQueryRequest(value: unknown): value is MissionListQueryRequest;
+export declare function decodeMissionListQueryRequest(value: unknown): MissionListQueryRequest | null;
+export declare function isMissionListQueryResponse(value: unknown): value is MissionListQueryResponse;
+export declare function decodeMissionListQueryResponse(value: unknown): MissionListQueryResponse | null;
+export declare const OPERATING_NOTE_CATEGORIES: readonly ["provider_quirk", "pattern_to_avoid", "recovery_lesson"];
+export type OperatingNoteCategory = typeof OPERATING_NOTE_CATEGORIES[number];
+export declare const isOperatingNoteCategory: (value: unknown) => value is "provider_quirk" | "pattern_to_avoid" | "recovery_lesson";
+export interface NoteUpsertRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** Free text (local IPC — see the section note). */
+    text: string;
+    category?: OperatingNoteCategory;
+    pinned?: boolean;
+    /** Explicit expiry, ISO-8601. */
+    expiresAt?: string;
+    /** Note id (or subject key) this note supersedes. */
+    supersedes?: string;
+    subjectKey?: string;
+    /** Best-effort identity of the recording coordinator (session id / daemon id / host). */
+    sourceCoordinator?: string;
+}
+export interface NoteUpsertResponse {
+    noteId: string;
+    /** True when the same text was already among the recent live notes (no new note). */
+    deduped: boolean;
+    createdAt: string;
+}
+export declare function isNoteUpsertRequest(value: unknown): value is NoteUpsertRequest;
+export declare function decodeNoteUpsertRequest(value: unknown): NoteUpsertRequest | null;
+export declare function isNoteUpsertResponse(value: unknown): value is NoteUpsertResponse;
+export declare function decodeNoteUpsertResponse(value: unknown): NoteUpsertResponse | null;
+export interface NoteForgetRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** At least one of `noteId` / `text` (a text forget retracts every note with that exact text, and any recorded later). */
+    noteId?: string;
+    text?: string;
+    reason?: string;
+}
+export interface NoteForgetResponse {
+    /** Live notes this forget hid. */
+    matched: number;
+    tombstoneId: string;
+}
+export declare function isNoteForgetRequest(value: unknown): value is NoteForgetRequest;
+export declare function decodeNoteForgetRequest(value: unknown): NoteForgetRequest | null;
+export declare function isNoteForgetResponse(value: unknown): value is NoteForgetResponse;
+export declare function decodeNoteForgetResponse(value: unknown): NoteForgetResponse | null;
+export declare const TOOL_CALLER_ROLES: readonly ["coordinator", "unknown"];
+export type ToolCallerRole = typeof TOOL_CALLER_ROLES[number];
+export declare const isToolCallerRole: (value: unknown) => value is "unknown" | "coordinator";
+export interface ToolCallRecordRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** The mesh tool name, e.g. `mesh_status` (identifier, not free text — always a fixed tool-name string). */
+    tool: string;
+    sessionId?: string;
+    callerRole: ToolCallerRole;
+}
+export interface ToolCallRecordResponse {
+    rateLimitExceeded: boolean;
+    callsInWindow: number;
+    /** Short machine-oriented advisory string, or null. Never free text describing content. */
+    advisory: string | null;
+}
+export declare function isToolCallRecordRequest(value: unknown): value is ToolCallRecordRequest;
+export declare function decodeToolCallRecordRequest(value: unknown): ToolCallRecordRequest | null;
+export declare function isToolCallRecordResponse(value: unknown): value is ToolCallRecordResponse;
+export declare function decodeToolCallRecordResponse(value: unknown): ToolCallRecordResponse | null;
+export interface LedgerQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** One or more ledger `kind` strings (daemon-core `MeshLedgerKind`; mesh-shared cannot import that union, so these are identifiers here). Omitted = every kind. */
+    kind?: readonly string[];
+    /** ISO-8601 or epoch-ms-as-string — passed through to `readLedgerEntries`'s `since` (parsed via `new Date()`). */
+    since?: string;
+    /** Filter to entries whose nodeId is equivalent to this daemon id (matched via `daemonIdsEquivalent` daemon-side, not raw `===`). */
+    node?: string;
+    tail?: number;
+    /** Also return `getLedgerSummary(meshId)` alongside the entries — saves a second round trip for callers that want both (the common case: every existing call site fetches both together). */
+    includeSummary?: boolean;
+}
+export interface LedgerQueryEntryWire {
+    id: string;
+    meshId: string;
+    timestamp: string;
+    kind: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskId?: string;
+    /** Unbounded JSON passthrough — see file section's CONTENT BOUNDARY note. */
+    payload: Record<string, unknown>;
+}
+export interface LedgerQuerySummaryWire {
+    meshId: string;
+    totalEntries: number;
+    taskDispatched: number;
+    taskCompleted: number;
+    taskFailed: number;
+    taskStalled: number;
+    sessionLaunched: number;
+    checkpointCreated: number;
+    lastActivityAt: string | null;
+    recentFailures: number;
+}
+export interface LedgerQueryResponse {
+    entries: readonly LedgerQueryEntryWire[];
+    summary?: LedgerQuerySummaryWire;
+}
+export declare function isLedgerQueryRequest(value: unknown): value is LedgerQueryRequest;
+export declare function decodeLedgerQueryRequest(value: unknown): LedgerQueryRequest | null;
+export declare function isLedgerQueryResponse(value: unknown): value is LedgerQueryResponse;
+export declare function decodeLedgerQueryResponse(value: unknown): LedgerQueryResponse | null;
+/** A queue row as the daemon's `getQueue` returns it — a JSON passthrough (see the section note). */
+export type QueueEntryWire = Record<string, unknown> & {
+    id: string;
+    status: string;
+};
+export interface RecordLocalRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** A `MeshLedgerKind` (daemon-core); an identifier here (mesh-shared cannot import that union). */
+    kind: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskId?: string;
+    payload: Record<string, unknown>;
+}
+export interface RecordLocalResponse {
+    eventId: string;
+    timestamp: string;
+    storedLocally: boolean;
+    published: boolean;
+}
+export declare function isRecordLocalRequest(value: unknown): value is RecordLocalRequest;
+export declare function decodeRecordLocalRequest(value: unknown): RecordLocalRequest | null;
+export declare function isRecordLocalResponse(value: unknown): value is RecordLocalResponse;
+export declare function decodeRecordLocalResponse(value: unknown): RecordLocalResponse | null;
+export interface QueueQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** Status filter (queue statuses); omitted = every row. */
+    statuses?: readonly string[];
+    /** One row by id (returns 0 or 1 entries). */
+    taskId?: string;
+    /** Project for a VIEW surface: the persisted input envelope → `inputSummary` (summarizeQueueEntryInputForView). */
+    view?: boolean;
+}
+export interface QueueQueryResponse {
+    entries: readonly QueueEntryWire[];
+}
+export declare function isQueueQueryRequest(value: unknown): value is QueueQueryRequest;
+export declare function decodeQueueQueryRequest(value: unknown): QueueQueryRequest | null;
+export declare function isQueueQueryResponse(value: unknown): value is QueueQueryResponse;
+export declare function decodeQueueQueryResponse(value: unknown): QueueQueryResponse | null;
+export interface QueueEnqueueRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** Free text (the task message — see the section note). */
+    message: string;
+    options?: Record<string, unknown>;
+    /** `recordSingleEnqueueDecision` args minus `taskId` (the daemon fills it). */
+    decision?: Record<string, unknown>;
+}
+export interface QueueEnqueueResponse {
+    entry: QueueEntryWire;
+}
+export declare function isQueueEnqueueRequest(value: unknown): value is QueueEnqueueRequest;
+export declare function decodeQueueEnqueueRequest(value: unknown): QueueEnqueueRequest | null;
+export declare function isQueueEnqueueResponse(value: unknown): value is QueueEnqueueResponse;
+export declare function decodeQueueEnqueueResponse(value: unknown): QueueEnqueueResponse | null;
+export interface QueueEnqueueGraphRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    mode: 'compat' | 'graph';
+    /** compat: `MeshTaskGraphEntrySpec[]` (JSON passthrough). */
+    specs?: readonly Record<string, unknown>[];
+    /** graph: `commitMeshGraphPlan` input minus `meshId` (JSON passthrough). */
+    plan?: Record<string, unknown>;
+    /** Audit context: batchId / missionId / coordinatorSessionId / onDependencyFailure / orchestrationDecision / taskCount. */
+    audit?: Record<string, unknown>;
+}
+export type QueueEnqueueGraphResponse = {
+    ok: true;
+    tasks: readonly QueueEntryWire[];
+    graph?: Record<string, unknown>;
+} | {
+    ok: false;
+    refusalCode?: string;
+    message: string;
+    extra?: Record<string, unknown>;
+};
+export declare function isQueueEnqueueGraphRequest(value: unknown): value is QueueEnqueueGraphRequest;
+export declare function decodeQueueEnqueueGraphRequest(value: unknown): QueueEnqueueGraphRequest | null;
+export declare function isQueueEnqueueGraphResponse(value: unknown): value is QueueEnqueueGraphResponse;
+export declare function decodeQueueEnqueueGraphResponse(value: unknown): QueueEnqueueGraphResponse | null;
+export interface QueueCancelRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    taskId: string;
+    /** Operator reason (free text, local IPC). */
+    reason?: string;
+}
+export interface QueueCancelResponse {
+    /** The cancelled row, or null when no such task. */
+    task: QueueEntryWire | null;
+    /** The row as it was BEFORE the cancel (its assignment is what a caller stops). */
+    before: QueueEntryWire | null;
+}
+export declare function isQueueCancelRequest(value: unknown): value is QueueCancelRequest;
+export declare function decodeQueueCancelRequest(value: unknown): QueueCancelRequest | null;
+export declare function isQueueCancelResponse(value: unknown): value is QueueCancelResponse;
+export declare function decodeQueueCancelResponse(value: unknown): QueueCancelResponse | null;
+export interface QueueRequeueRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    taskId: string;
+    /** `requeueTask` options (reason / targetNodeId / targetSessionId / clear* / force / message / maxRetries / notBefore), JSON passthrough. */
+    options?: Record<string, unknown>;
+}
+export interface QueueRequeueResponse {
+    task: QueueEntryWire | null;
+}
+export declare function isQueueRequeueRequest(value: unknown): value is QueueRequeueRequest;
+export declare function decodeQueueRequeueRequest(value: unknown): QueueRequeueRequest | null;
+export declare function isQueueRequeueResponse(value: unknown): value is QueueRequeueResponse;
+export declare function decodeQueueRequeueResponse(value: unknown): QueueRequeueResponse | null;
+export interface DirectDispatchRecordRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    taskId: string;
+    /** Free text (the authored task message — the materialised row keeps it). */
+    message: string;
+    /** `recordDirectDispatchTask` options minus `id` (JSON passthrough). */
+    task?: Record<string, unknown>;
+    /** `recordDirectDispatchDecision` args minus `taskId` (JSON passthrough). */
+    decision?: Record<string, unknown>;
+}
+export interface DirectDispatchRecordResponse {
+    taskRecorded: boolean;
+    decisionRecorded: boolean;
+}
+export declare function isDirectDispatchRecordRequest(value: unknown): value is DirectDispatchRecordRequest;
+export declare function decodeDirectDispatchRecordRequest(value: unknown): DirectDispatchRecordRequest | null;
+export declare function isDirectDispatchRecordResponse(value: unknown): value is DirectDispatchRecordResponse;
+export declare function decodeDirectDispatchRecordResponse(value: unknown): DirectDispatchRecordResponse | null;
+export declare const GRAPH_AUDIT_EVENTS: readonly ["gate_claimed", "gate_released", "gate_abandoned", "node_patched"];
+export type GraphAuditEvent = typeof GRAPH_AUDIT_EVENTS[number];
+export declare const isGraphAuditEvent: (value: unknown) => value is "gate_claimed" | "gate_released" | "gate_abandoned" | "node_patched";
+export interface GraphAuditRecordRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    event: GraphAuditEvent;
+    fields: Record<string, unknown>;
+}
+export interface GraphAuditRecordResponse {
+    recorded: boolean;
+}
+export declare function isGraphAuditRecordRequest(value: unknown): value is GraphAuditRecordRequest;
+export declare function decodeGraphAuditRecordRequest(value: unknown): GraphAuditRecordRequest | null;
+export declare function isGraphAuditRecordResponse(value: unknown): value is GraphAuditRecordResponse;
+export declare function decodeGraphAuditRecordResponse(value: unknown): GraphAuditRecordResponse | null;
+export interface ActiveWorkQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    /** Live node probe results (`buildMeshActiveWork`'s `nodes`), JSON passthrough. */
+    nodes?: readonly Record<string, unknown>[];
+    /** Substitute queue rows (default: the daemon's `getQueue`). */
+    queue?: readonly Record<string, unknown>[];
+    /** Record tail fed to active work (default 200). */
+    recordTail?: number;
+    includeTerminalDirect?: boolean;
+    /** Default true. */
+    compute?: boolean;
+    includeInputs?: boolean;
+    includeSummary?: boolean;
+    includeSchedulingRuntime?: boolean;
+    /** The caller's mesh snapshot (required for the scheduling runtime), JSON passthrough. */
+    mesh?: Record<string, unknown>;
+}
+export interface ActiveWorkQueryResponse {
+    /** `MeshActiveWorkEvidence` (daemon-core), JSON passthrough; absent when `compute: false`. */
+    activeWork?: Record<string, unknown>;
+    records?: readonly Record<string, unknown>[];
+    directDispatches?: readonly Record<string, unknown>[];
+    /** `MeshLedgerSummary`-shaped record summary. */
+    summary?: Record<string, unknown>;
+    schedulingRuntime?: Record<string, unknown>;
+}
+export declare function isActiveWorkQueryRequest(value: unknown): value is ActiveWorkQueryRequest;
+export declare function decodeActiveWorkQueryRequest(value: unknown): ActiveWorkQueryRequest | null;
+export declare function isActiveWorkQueryResponse(value: unknown): value is ActiveWorkQueryResponse;
+export declare function decodeActiveWorkQueryResponse(value: unknown): ActiveWorkQueryResponse | null;
+export interface RecoveryContextQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    nodeId?: string;
+    sessionId?: string;
+    maxRetries?: number;
+}
+export interface RecoveryContextQueryResponse {
+    context: Record<string, unknown>;
+}
+export declare function isRecoveryContextQueryRequest(value: unknown): value is RecoveryContextQueryRequest;
+export declare function decodeRecoveryContextQueryRequest(value: unknown): RecoveryContextQueryRequest | null;
+export declare function isRecoveryContextQueryResponse(value: unknown): value is RecoveryContextQueryResponse;
+export declare function decodeRecoveryContextQueryResponse(value: unknown): RecoveryContextQueryResponse | null;
+export interface GraphGateClaimRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    gateId: string;
+    coordinatorSessionId: string;
+    leaseSeconds?: number;
+    extendDeadlineSeconds?: number;
+    /** Also collect `collectGateConvergenceEvidence` on a successful claim (mesh_graph_gate_claim's own behavior). */
+    probeConvergenceEvidence?: boolean;
+}
+export interface GraphGateClaimResponse {
+    claimed: boolean;
+    /** gate_not_found / gate_not_eligible / gate_not_awaiting / gate_lease_held / gate_claim_race / gate_terminal:<state> / gate_not_claimable, when `claimed: false`. */
+    reason?: string;
+    /** `MeshGraphGateRow`, JSON passthrough; present whenever the core found the gate. */
+    gate?: Record<string, unknown>;
+    leaseGeneration?: number;
+    fencingToken?: string;
+    leaseExpiresAt?: string;
+    deadlineAt?: string;
+    ambiguousExternalOutcome?: boolean;
+    previousLeaseOwnerSessionId?: string;
+    /** `GateConvergenceEvidence`, JSON passthrough; present only when requested and found. */
+    convergenceEvidence?: Record<string, unknown>;
+}
+export declare function isGraphGateClaimRequest(value: unknown): value is GraphGateClaimRequest;
+export declare function decodeGraphGateClaimRequest(value: unknown): GraphGateClaimRequest | null;
+export declare function isGraphGateClaimResponse(value: unknown): value is GraphGateClaimResponse;
+export declare function decodeGraphGateClaimResponse(value: unknown): GraphGateClaimResponse | null;
+export interface GraphGateReleaseRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    gateId: string;
+    fencingToken: string;
+    leaseGeneration: number;
+    idempotencyKey: string;
+    outcome: string;
+    /** Action-specific structured result/evidence the CALLER supplied — JSON passthrough, echoed back unmodified. */
+    result?: unknown;
+    evidence?: unknown;
+    patches?: readonly {
+        node: string;
+        baseSpecPatch: Record<string, unknown>;
+    }[];
+}
+export type GraphGateReleaseResponse = {
+    released: true;
+    duplicate: boolean;
+    gate?: Record<string, unknown>;
+    materializedNodeIds: readonly string[];
+    downstreamNodeCount?: number;
+    graphCompleted?: boolean;
+} | {
+    released: false;
+    refusalCode?: string;
+    message: string;
+};
+export declare function isGraphGateReleaseRequest(value: unknown): value is GraphGateReleaseRequest;
+export declare function decodeGraphGateReleaseRequest(value: unknown): GraphGateReleaseRequest | null;
+export declare function isGraphGateReleaseResponse(value: unknown): value is GraphGateReleaseResponse;
+export declare function decodeGraphGateReleaseResponse(value: unknown): GraphGateReleaseResponse | null;
+export interface GraphGateAbandonRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    gateId: string;
+    reason: string;
+    coordinatorSessionId?: string;
+    force?: boolean;
+}
+export interface GraphGateAbandonResponse {
+    abandoned: boolean;
+    /** gate_not_found / gate_lease_held / gate_abandon_race / gate_terminal:<state> / gate_not_abandonable, when `abandoned: false`. */
+    reason?: string;
+    gate?: Record<string, unknown>;
+    cancelledNodeIds: readonly string[];
+    cancelledTaskIds: readonly string[];
+    graphStatus?: string;
+}
+export declare function isGraphGateAbandonRequest(value: unknown): value is GraphGateAbandonRequest;
+export declare function decodeGraphGateAbandonRequest(value: unknown): GraphGateAbandonRequest | null;
+export declare function isGraphGateAbandonResponse(value: unknown): value is GraphGateAbandonResponse;
+export declare function decodeGraphGateAbandonResponse(value: unknown): GraphGateAbandonResponse | null;
+export interface GraphNodePatchRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    node: string;
+    graphId?: string;
+    /** Only {@link MESH_NODE_PATCH_KEYS}-shaped keys are permitted; the daemon enforces the allow-list. */
+    baseSpecPatch: Record<string, unknown>;
+}
+export type GraphNodePatchResponse = {
+    patched: true;
+    graphId: string;
+    nodeId: string;
+    ref?: string;
+    queueTaskId?: string;
+    materializationVersion: number;
+    state: string;
+    /** `SettleOutcome['kind']` — materialized / deferred / skipped / error. */
+    outcomeKind: string;
+    /** Present when `outcomeKind === 'skipped'`. */
+    skippedReason?: string;
+    blockedReason?: string;
+} | {
+    patched: false;
+    refusalCode?: string;
+    message: string;
+};
+export declare function isGraphNodePatchRequest(value: unknown): value is GraphNodePatchRequest;
+export declare function decodeGraphNodePatchRequest(value: unknown): GraphNodePatchRequest | null;
+export declare function isGraphNodePatchResponse(value: unknown): value is GraphNodePatchResponse;
+export declare function decodeGraphNodePatchResponse(value: unknown): GraphNodePatchResponse | null;
+export interface GraphViewQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    graphId?: string;
+    batchId?: string;
+    /** Default true: only graphs that still need attention. */
+    activeOnly?: boolean;
+    limit?: number;
+    /** Attach `collectGateConvergenceEvidence` to the first few waiting gates (mesh_graph_view's G4 opt-in probe). */
+    probeGateEvidence?: boolean;
+}
+export interface GraphViewQueryResponse {
+    /** `MeshGraphView[]`, JSON passthrough — see this section's content-boundary note. */
+    graphs: readonly Record<string, unknown>[];
+}
+export declare function isGraphViewQueryRequest(value: unknown): value is GraphViewQueryRequest;
+export declare function decodeGraphViewQueryRequest(value: unknown): GraphViewQueryRequest | null;
+export declare function isGraphViewQueryResponse(value: unknown): value is GraphViewQueryResponse;
+export declare function decodeGraphViewQueryResponse(value: unknown): GraphViewQueryResponse | null;
+export interface TaskStatsQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    taskIds?: readonly string[];
+    missionId?: string;
+    tail?: number;
+    /** Also compute `computeMeshMissionStats` — requires `missionId`. */
+    rollup?: boolean;
+}
+export interface TaskStatsQueryResponse {
+    /** `MeshTaskStats[]`, JSON passthrough. */
+    tasks: readonly Record<string, unknown>[];
+    /** `MeshMissionStats`, JSON passthrough; present only when `rollup: true` was requested and satisfiable. */
+    mission?: Record<string, unknown>;
+}
+export declare function isTaskStatsQueryRequest(value: unknown): value is TaskStatsQueryRequest;
+export declare function decodeTaskStatsQueryRequest(value: unknown): TaskStatsQueryRequest | null;
+export declare function isTaskStatsQueryResponse(value: unknown): value is TaskStatsQueryResponse;
+export declare function decodeTaskStatsQueryResponse(value: unknown): TaskStatsQueryResponse | null;
+export interface PruneStaleDirectRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    execute?: boolean;
+    includeTerminal?: boolean;
+    source?: string;
+}
+export interface PruneStaleDirectResponse {
+    mode: 'execute' | 'dry_run';
+    includeTerminal: boolean;
+    candidateCount: number;
+    /** `MeshActiveWorkRecord[]`, JSON passthrough. */
+    prunable: readonly Record<string, unknown>[];
+    prunedCount: number;
+    preservedUnacknowledged: readonly Record<string, unknown>[];
+    preservedLedgerOnly: readonly Record<string, unknown>[];
+    preservedNotOrphan: readonly Record<string, unknown>[];
+}
+export declare function isPruneStaleDirectRequest(value: unknown): value is PruneStaleDirectRequest;
+export declare function decodePruneStaleDirectRequest(value: unknown): PruneStaleDirectRequest | null;
+export declare function isPruneStaleDirectResponse(value: unknown): value is PruneStaleDirectResponse;
+export declare function decodePruneStaleDirectResponse(value: unknown): PruneStaleDirectResponse | null;
+export interface OrphanedPinNotifyRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    stoppedSessionId: string;
+    excludeTaskId?: string;
+    cause?: string;
+    nodeId?: string;
+    coordinatorSessionId?: string;
+}
+export interface OrphanedPinnedTaskWire {
+    taskId: string;
+    title: string;
+    targetSessionId: string;
+    targetNodeId?: string;
+    missionId?: string;
+}
+export interface OrphanedPinNotifyResponse {
+    orphans: readonly OrphanedPinnedTaskWire[];
+}
+export declare function isOrphanedPinNotifyRequest(value: unknown): value is OrphanedPinNotifyRequest;
+export declare function decodeOrphanedPinNotifyRequest(value: unknown): OrphanedPinNotifyRequest | null;
+export declare function isOrphanedPinNotifyResponse(value: unknown): value is OrphanedPinNotifyResponse;
+export declare function decodeOrphanedPinNotifyResponse(value: unknown): OrphanedPinNotifyResponse | null;
+/** The complete, closed set of IPC command names this contract defines. */
+export declare const TURN_IPC_COMMANDS: readonly ["turn_observe", "mesh_record", "turn_cancel", "operator_status", "turn_query", "mesh_index_query", "mission_upsert", "mission_query", "note_upsert", "note_forget", "tool_call_record", "ledger_query", "mission_list_query", "record_local", "queue_query", "queue_enqueue", "queue_enqueue_graph", "queue_cancel", "queue_requeue", "direct_dispatch_record", "graph_audit_record", "active_work_query", "recovery_context_query", "graph_gate_claim", "graph_gate_release", "graph_gate_abandon", "graph_node_patch", "graph_view_query", "task_stats_query", "prune_stale_direct", "orphaned_pin_notify"];
+export type TurnIpcCommand = typeof TURN_IPC_COMMANDS[number];
+export declare const isTurnIpcCommand: (value: unknown) => value is "operator_status" | "turn_observe" | "mesh_record" | "turn_cancel" | "turn_query" | "mesh_index_query" | "mission_upsert" | "mission_query" | "note_upsert" | "note_forget" | "tool_call_record" | "ledger_query" | "mission_list_query" | "record_local" | "queue_query" | "queue_enqueue" | "queue_enqueue_graph" | "queue_cancel" | "queue_requeue" | "direct_dispatch_record" | "graph_audit_record" | "active_work_query" | "recovery_context_query" | "graph_gate_claim" | "graph_gate_release" | "graph_gate_abandon" | "graph_node_patch" | "graph_view_query" | "task_stats_query" | "prune_stale_direct" | "orphaned_pin_notify";
+/** Request type keyed by command name — for a generically-typed dispatcher on either end. */
+export interface TurnIpcRequestByCommand {
+    turn_observe: TurnObserveRequest;
+    mesh_record: MeshRecordRequest;
+    turn_cancel: TurnCancelRequest;
+    operator_status: OperatorStatusRequest;
+    turn_query: TurnQueryRequest;
+    mesh_index_query: MeshIndexQueryRequest;
+    mission_upsert: MissionUpsertRequest;
+    mission_query: MissionQueryRequest;
+    note_upsert: NoteUpsertRequest;
+    note_forget: NoteForgetRequest;
+    tool_call_record: ToolCallRecordRequest;
+    ledger_query: LedgerQueryRequest;
+    mission_list_query: MissionListQueryRequest;
+    record_local: RecordLocalRequest;
+    queue_query: QueueQueryRequest;
+    queue_enqueue: QueueEnqueueRequest;
+    queue_enqueue_graph: QueueEnqueueGraphRequest;
+    queue_cancel: QueueCancelRequest;
+    queue_requeue: QueueRequeueRequest;
+    direct_dispatch_record: DirectDispatchRecordRequest;
+    graph_audit_record: GraphAuditRecordRequest;
+    active_work_query: ActiveWorkQueryRequest;
+    recovery_context_query: RecoveryContextQueryRequest;
+    graph_gate_claim: GraphGateClaimRequest;
+    graph_gate_release: GraphGateReleaseRequest;
+    graph_gate_abandon: GraphGateAbandonRequest;
+    graph_node_patch: GraphNodePatchRequest;
+    graph_view_query: GraphViewQueryRequest;
+    task_stats_query: TaskStatsQueryRequest;
+    prune_stale_direct: PruneStaleDirectRequest;
+    orphaned_pin_notify: OrphanedPinNotifyRequest;
+}
+/** Response type keyed by command name — for a generically-typed dispatcher on either end. */
+export interface TurnIpcResponseByCommand {
+    turn_observe: TurnObserveResponse;
+    mesh_record: MeshRecordResponse;
+    turn_cancel: TurnCancelResponse;
+    operator_status: OperatorStatusResponse;
+    turn_query: TurnQueryResponse;
+    mission_upsert: MissionUpsertResponse;
+    mission_query: MissionQueryResponse;
+    mesh_index_query: MeshIndexQueryResponse;
+    note_upsert: NoteUpsertResponse;
+    note_forget: NoteForgetResponse;
+    tool_call_record: ToolCallRecordResponse;
+    ledger_query: LedgerQueryResponse;
+    mission_list_query: MissionListQueryResponse;
+    record_local: RecordLocalResponse;
+    queue_query: QueueQueryResponse;
+    queue_enqueue: QueueEnqueueResponse;
+    queue_enqueue_graph: QueueEnqueueGraphResponse;
+    queue_cancel: QueueCancelResponse;
+    queue_requeue: QueueRequeueResponse;
+    direct_dispatch_record: DirectDispatchRecordResponse;
+    graph_audit_record: GraphAuditRecordResponse;
+    active_work_query: ActiveWorkQueryResponse;
+    recovery_context_query: RecoveryContextQueryResponse;
+    graph_gate_claim: GraphGateClaimResponse;
+    graph_gate_release: GraphGateReleaseResponse;
+    graph_gate_abandon: GraphGateAbandonResponse;
+    graph_node_patch: GraphNodePatchResponse;
+    graph_view_query: GraphViewQueryResponse;
+    task_stats_query: TaskStatsQueryResponse;
+    prune_stale_direct: PruneStaleDirectResponse;
+    orphaned_pin_notify: OrphanedPinNotifyResponse;
+}