@adhdev/mesh-shared 1.0.60-rc.72 → 1.0.60-rc.74

package/dist/json.d.ts

@@ -9,7 +9,11 @@
  */
 export type JsonRecord = Record<string, unknown>;
 export declare function readRecord(value: unknown): JsonRecord;
+/** A plain-object record, or undefined — for callers that must tell "absent" from "empty". */
+export declare function readOptionalRecord(value: unknown): JsonRecord | undefined;
 export declare function readString(...values: unknown[]): string | undefined;
+/** The first non-blank trimmed string, or '' — readString for callers that want a plain string. */
+export declare function readText(...values: unknown[]): string;
 export declare function readNumber(...values: unknown[]): number | undefined;
 export declare function readBoolean(...values: unknown[]): boolean | undefined;
 export declare function readStringArray(value: unknown): string[];

package/dist/mesh-tool-names.d.ts

@@ -18,10 +18,10 @@
  * Order mirrors mcp-server `ALL_MESH_TOOLS` for easy visual diffing, but the consistency
  * checks are set-based (order-insensitive).
  */
-export declare const CANONICAL_MESH_TOOL_NAMES: readonly ["mesh_status", "mesh_route_preview", "mesh_list_nodes", "mesh_enqueue_batch", "mesh_enqueue_task", "mesh_view_queue", "mesh_graph_view", "mesh_graph_gate", "mesh_graph_node_patch", "mesh_queue_cancel", "mesh_queue_requeue", "mesh_send_task", "mesh_read_chat", "mesh_read_debug", "mesh_read_terminal", "mesh_send_keys", "mesh_launch_session", "mesh_git_status", "mesh_read_node_logs", "mesh_fast_forward_node", "mesh_restart_daemon", "mesh_checkpoint", "mesh_approve", "mesh_answer_question", "mesh_list_pending_approvals", "mesh_create", "mesh_add_node", "mesh_clone_node", "mesh_remove_node", "mesh_cleanup_worktree_nodes", "mesh_refine_node", "mesh_refine_batch", "mesh_config", "mesh_init", "mesh_refine_plan", "mesh_cleanup_sessions", "mesh_task_history", "mesh_ledger_query", "mesh_note", "mesh_reconcile_ledger", "mesh_mission_upsert", "mesh_mission_list", "mesh_review_inbox", "mesh_magi_review", "mesh_magi_collect", "mesh_magi_kind_panel", "mesh_node_slots", "mesh_coordinator_prompt_append"];
+export declare const CANONICAL_MESH_TOOL_NAMES: readonly ["mesh_status", "mesh_route_preview", "mesh_list_nodes", "mesh_enqueue_batch", "mesh_enqueue_task", "mesh_view_queue", "mesh_queue_cancel", "mesh_queue_requeue", "mesh_send_task", "mesh_read_chat", "mesh_read_debug", "mesh_read_terminal", "mesh_send_keys", "mesh_launch_session", "mesh_git_status", "mesh_read_node_logs", "mesh_fast_forward_node", "mesh_restart_daemon", "mesh_checkpoint", "mesh_approve", "mesh_answer_question", "mesh_list_pending_approvals", "mesh_create", "mesh_add_node", "mesh_clone_node", "mesh_remove_node", "mesh_cleanup_worktree_nodes", "mesh_refine_node", "mesh_refine_batch", "mesh_config", "mesh_init", "mesh_refine_plan", "mesh_cleanup_sessions", "mesh_task_history", "mesh_ledger_query", "mesh_note", "mesh_reconcile_ledger", "mesh_mission_upsert", "mesh_mission_list", "mesh_review_inbox", "mesh_node_slots", "mesh_coordinator_prompt_append"];
 export type CanonicalMeshToolName = typeof CANONICAL_MESH_TOOL_NAMES[number];
 /** The count the `NN tools` barrel doc comments and consistency test assert against. */
-export declare const CANONICAL_MESH_TOOL_COUNT: 48;
+export declare const CANONICAL_MESH_TOOL_COUNT: 42;
 /**
  * Tool names retired by the 2026-09-26 tool-surface consolidation (60 → 48).
  * Every capability behind them is still reachable: each retired name maps to the
@@ -33,8 +33,7 @@ export declare const CANONICAL_MESH_TOOL_COUNT: 48;
  * test asserts none of these names is advertised anywhere in the prompt.
  *
  * `args` is the discriminator to add; every other argument keeps its name.
- * `note` covers the one rename where an argument moved (the old
- * `mesh_graph_gate_claim({ extend_seconds })` extend-only mode).
+ * `note` carries any extra guidance when an argument moved in a rename.
  */
 export declare const RETIRED_MESH_TOOLS: Readonly<Record<string, {
     readonly tool: CanonicalMeshToolName;
@@ -42,8 +41,13 @@ export declare const RETIRED_MESH_TOOLS: Readonly<Record<string, {
     readonly note?: string;
 }>>;
 /**
- * The error text for a call to a retired tool name, or null when `name` is not
- * retired. One wording shared by every MCP mode so the redirect reads the same
- * wherever an old prompt calls it.
+ * Tool names removed outright (no merged replacement), mapped to the guidance a
+ * coordinator on an old prompt needs to do the same job with the remaining tools.
+ */
+export declare const REMOVED_MESH_TOOLS: Readonly<Record<string, string>>;
+/**
+ * The error text for a call to a retired or removed tool name, or null when
+ * `name` is neither. One wording shared by every MCP mode so the redirect reads
+ * the same wherever an old prompt calls it.
  */
 export declare function retiredMeshToolError(name: string): string | null;

package/dist/mesh-vocabulary.d.ts

@@ -38,8 +38,7 @@ export type MeshThinkingLevel = typeof MESH_THINKING_LEVELS[number];
 export declare const MESH_DELIVERY_MODES: readonly ["when_idle", "interrupt"];
 export type MeshDeliveryMode = typeof MESH_DELIVERY_MODES[number];
 /**
- * What to do with a node's sessions when the node is removed or a MAGI fan-out
- * settles. Declared here so daemon-core (`RepoMeshSessionCleanupMode`), the
+ * What to do with a node's sessions when the node is removed. Declared here so daemon-core (`RepoMeshSessionCleanupMode`), the
  * web dashboard picker and the MCP schemas all read one list.
  */
 export declare const MESH_SESSION_CLEANUP_MODES: readonly ["preserve", "stop", "delete_stopped", "stop_and_delete"];

package/dist/outbound-message.d.ts

@@ -132,9 +132,8 @@ export type SendRefusal = 'not_ready' | 'send_in_flight' | 'not_generating' | 'n
  *                   a turn is generating (`send_now`). Written, not yet answered;
  *   `interrupt`   — the turn in flight was stopped first, then this body was
  *                   written (or re-parked) as a new turn;
- *   `acp`         — handed to an ACP agent's `session/prompt`.
  */
-export type SubmitRoute = 'pty' | 'agent_queue' | 'interrupt' | 'acp';
+export type SubmitRoute = 'pty' | 'agent_queue' | 'interrupt';
 /** The stop key pressed by an `interrupt` submit (logs / operator display). */
 export interface SubmitInterruptDetail {
     keyName: string;

package/dist/protocol/daemon-server.d.ts

@@ -157,11 +157,6 @@ export type AuthOkWirePayload = {
     machineNickname: string | null;
     seqscribeFleetSecret?: string;
     seqscribeFleetSecretVersion?: number;
-    /** Beacon board seed for cold start (advisory, may be absent). */
-    beaconSeed?: {
-        reports: unknown[];
-        truncated: number;
-    };
     limits: AuthOkPlanLimits;
 };
 export type AuthErrorWirePayload = {
@@ -207,14 +202,6 @@ export type DaemonErrorWirePayload = {
     message?: string;
     detail?: unknown;
 };
-export type BeaconVectorsWirePayload = {
-    op: 'put';
-    report: unknown;
-} | {
-    op: 'get';
-    topics: string[];
-    requestId: string;
-};
 export declare const P2P_SIGNAL_TYPES: readonly ["p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice"];
 export type P2PSignalType = typeof P2P_SIGNAL_TYPES[number];
 export declare const isP2PSignalType: (value: unknown) => value is "p2p_ready" | "p2p_offer" | "p2p_answer" | "p2p_ice";
@@ -258,9 +245,9 @@ export declare const isMeshP2PSignalType: (value: unknown) => value is "mesh_p2p
 export type MeshP2PSignalWirePayload = {
     senderDaemonId: string;
 } & Record<string, unknown>;
-export declare const DAEMON_TO_SERVER_TYPES: readonly ["auth", "status_report", "status_heartbeat", "status_event", "command_result", "error", "agent_event", "beacon_vectors", "daemon_mesh_command", "p2p_offer", "p2p_ice"];
+export declare const DAEMON_TO_SERVER_TYPES: readonly ["auth", "status_report", "status_heartbeat", "status_event", "command_result", "error", "agent_event", "daemon_mesh_command", "p2p_offer", "p2p_ice"];
 export type DaemonToServerType = typeof DAEMON_TO_SERVER_TYPES[number];
-export declare const isDaemonToServerType: (value: unknown) => value is "error" | "p2p_offer" | "p2p_ice" | "auth" | "status_report" | "status_heartbeat" | "status_event" | "command_result" | "agent_event" | "beacon_vectors" | "daemon_mesh_command";
+export declare const isDaemonToServerType: (value: unknown) => value is "error" | "p2p_offer" | "p2p_ice" | "auth" | "status_report" | "status_heartbeat" | "status_event" | "command_result" | "agent_event" | "daemon_mesh_command";
 export type DaemonAuthMsg = Envelope<'auth', DaemonAuthWirePayload>;
 export type StatusReportMsg = Envelope<'status_report', CloudStatusReportWirePayload>;
 export type StatusHeartbeatMsg = Envelope<'status_heartbeat', StatusHeartbeatWirePayload>;
@@ -269,7 +256,6 @@ export type CommandResultMsg = Envelope<'command_result', CommandResultWirePaylo
 export type DaemonErrorMsg = Envelope<'error', DaemonErrorWirePayload>;
 /** Agent-level event forwarded verbatim to the `agent:status` webhook (throttled server-side). Dynamic by design. */
 export type AgentEventMsg = Envelope<'agent_event', CommandPayload>;
-export type BeaconVectorsMsg = Envelope<'beacon_vectors', BeaconVectorsWirePayload>;
 export type DaemonP2POfferMsg = Envelope<'p2p_offer', P2POfferWirePayload>;
 export type DaemonP2PIceMsg = Envelope<'p2p_ice', P2PIceWirePayload>;
 /**
@@ -285,7 +271,7 @@ export type DaemonMeshCommandMsg = {
     args: Record<string, unknown>;
     timestamp: number;
 };
-export type DaemonToServerMsg = DaemonAuthMsg | StatusReportMsg | StatusHeartbeatMsg | DaemonStatusEventMsg | CommandResultMsg | DaemonErrorMsg | AgentEventMsg | BeaconVectorsMsg | DaemonMeshCommandMsg | DaemonP2POfferMsg | DaemonP2PIceMsg;
+export type DaemonToServerMsg = DaemonAuthMsg | StatusReportMsg | StatusHeartbeatMsg | DaemonStatusEventMsg | CommandResultMsg | DaemonErrorMsg | AgentEventMsg | DaemonMeshCommandMsg | DaemonP2POfferMsg | DaemonP2PIceMsg;
 /** Members that carry a `payload` object (everything except `daemon_mesh_command`). */
 export type DaemonToServerPayloadType = Exclude<DaemonToServerMsg, DaemonMeshCommandMsg>['type'];
 export type DaemonToServerPayloadOf<T extends DaemonToServerPayloadType> = Extract<DaemonToServerMsg, {
@@ -297,9 +283,9 @@ export type DaemonToServerPayloadOf<T extends DaemonToServerPayloadType> = Extra
  * token string because nothing downstream can proceed without one.
  */
 export declare function decodeDaemonToServer(raw: unknown): DaemonToServerMsg | null;
-export declare const SERVER_TO_DAEMON_CONTROL_TYPES: readonly ["auth_ok", "auth_error", "machine_evicted", "force_disconnect", "token_revoked", "version_mismatch", "force_update_required", "command", "agent_command", "resolve_action", "beacon_vectors_result", "daemon_mesh_result", "p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice", "mesh_p2p_ready", "mesh_p2p_offer", "mesh_p2p_answer", "mesh_p2p_ice"];
+export declare const SERVER_TO_DAEMON_CONTROL_TYPES: readonly ["auth_ok", "auth_error", "machine_evicted", "force_disconnect", "token_revoked", "version_mismatch", "force_update_required", "command", "agent_command", "resolve_action", "daemon_mesh_result", "p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice", "mesh_p2p_ready", "mesh_p2p_offer", "mesh_p2p_answer", "mesh_p2p_ice"];
 export type ServerToDaemonControlType = typeof SERVER_TO_DAEMON_CONTROL_TYPES[number];
-export declare const isServerToDaemonControlType: (value: unknown) => value is "p2p_ready" | "p2p_offer" | "p2p_answer" | "p2p_ice" | "mesh_p2p_ready" | "mesh_p2p_offer" | "mesh_p2p_answer" | "mesh_p2p_ice" | "command" | "auth_ok" | "auth_error" | "machine_evicted" | "force_disconnect" | "token_revoked" | "version_mismatch" | "force_update_required" | "agent_command" | "resolve_action" | "beacon_vectors_result" | "daemon_mesh_result";
+export declare const isServerToDaemonControlType: (value: unknown) => value is "p2p_ready" | "p2p_offer" | "p2p_answer" | "p2p_ice" | "mesh_p2p_ready" | "mesh_p2p_offer" | "mesh_p2p_answer" | "mesh_p2p_ice" | "command" | "auth_ok" | "auth_error" | "machine_evicted" | "force_disconnect" | "token_revoked" | "version_mismatch" | "force_update_required" | "agent_command" | "resolve_action" | "daemon_mesh_result";
 /** Optional routing fields the server stamps on relayed commands. */
 type ServerRelayFields = {
     id?: MessageId;
@@ -324,15 +310,6 @@ export type ServerAgentCommandMsg = Envelope<'agent_command', {
 export type ServerResolveActionMsg = Envelope<'resolve_action', CommandPayload> & ServerRelayFields;
 export type ServerP2PSignalMsg = Envelope<P2PSignalType, RelayedP2PSignalWirePayload> & ServerRelayFields;
 export type ServerMeshP2PSignalMsg = Envelope<MeshP2PSignalType, MeshP2PSignalWirePayload> & ServerRelayFields;
-/** Reply to a `beacon_vectors` GET, correlated by `requestId` (top-level, no payload). A PUT gets no reply. */
-export type BeaconVectorsResultMsg = {
-    type: 'beacon_vectors_result';
-    requestId: string;
-    success: boolean;
-    reports?: unknown[];
-    truncated?: number;
-    error?: string;
-};
 /** Correlated ack/nack of a `daemon_mesh_command` (top-level, no payload). */
 export type DaemonMeshResultMsg = {
     type: 'daemon_mesh_result';
@@ -341,7 +318,7 @@ export type DaemonMeshResultMsg = {
     result?: unknown;
     error?: string;
 };
-export type ServerToDaemonControlMsg = AuthOkMsg | AuthErrorMsg | MachineEvictedMsg | ForceDisconnectMsg | TokenRevokedMsg | VersionMismatchMsg | ForceUpdateRequiredMsg | ServerCommandMsg | ServerAgentCommandMsg | ServerResolveActionMsg | BeaconVectorsResultMsg | DaemonMeshResultMsg | ServerP2PSignalMsg | ServerMeshP2PSignalMsg;
+export type ServerToDaemonControlMsg = AuthOkMsg | AuthErrorMsg | MachineEvictedMsg | ForceDisconnectMsg | TokenRevokedMsg | VersionMismatchMsg | ForceUpdateRequiredMsg | ServerCommandMsg | ServerAgentCommandMsg | ServerResolveActionMsg | DaemonMeshResultMsg | ServerP2PSignalMsg | ServerMeshP2PSignalMsg;
 declare const directCommandBrand: unique symbol;
 /**
  * A command name relayed as the frame `type` — the OPEN namespace the REST API
@@ -364,7 +341,7 @@ export type ServerToDaemonMsg = ServerToDaemonControlMsg | ServerDirectCommandMs
 export type ServerToDaemonType = ServerToDaemonMsg['type'];
 export declare function isServerDirectCommandMsg(msg: ServerToDaemonMsg): msg is ServerDirectCommandMsg;
 /** Members of the control set that carry a `payload` object. */
-export type ServerToDaemonPayloadType = Exclude<ServerToDaemonControlMsg, BeaconVectorsResultMsg | DaemonMeshResultMsg>['type'];
+export type ServerToDaemonPayloadType = Exclude<ServerToDaemonControlMsg, DaemonMeshResultMsg>['type'];
 export type ServerToDaemonPayloadOf<T extends ServerToDaemonPayloadType> = Extract<ServerToDaemonControlMsg, {
     type: T;
 }>['payload'];
@@ -372,7 +349,7 @@ export declare function isDaemonDirectCommandType(value: unknown): value is Daem
 /**
  * Parse boundary for the daemon: is `raw` a frame this link accepts from the server?
  * Control members are checked for their discriminant and envelope shape; the
- * two payload-less replies need their `requestId`; any other well-formed
+ * payload-less `daemon_mesh_result` reply needs its `requestId`; any other well-formed
  * command name becomes a `ServerDirectCommandMsg`.
  */
 export declare function decodeServerToDaemon(raw: unknown): ServerToDaemonMsg | null;

package/dist/session-launch.d.ts

@@ -19,14 +19,6 @@
  * passed through {@link sanitizeModelIdentifier}) and `modelSource` (an enum,
  * passed through {@link isModelAxisSource}). Never widen that to the record.
  */
-/**
- * Where a model / thinking-level value came from.
- *
- * `restore` is deliberately NOT a member: a hosted session re-attached after a
- * daemon restart keeps the ORIGINAL source (the user still picked that model);
- * only `SessionLaunchRecord.launchedBy` records that the session came back via
- * restore.
- */
 export declare const MODEL_AXIS_SOURCES: readonly ["user", "remembered", "mesh_slot", "task_override", "provider_default", "unspecified"];
 export type ModelAxisSource = typeof MODEL_AXIS_SOURCES[number];
 export declare function isModelAxisSource(value: unknown): value is ModelAxisSource;

package/dist/slot-proposal.d.ts

@@ -1,5 +1,5 @@
 /**
- * CLI auto-detect → capability-slot / MAGI-panel PROPOSAL generator.
+ * CLI auto-detect → capability-slot PROPOSAL generator.
  *
  * Detection of installed CLI providers already exists per node (the status
  * snapshot's `availableProviders`), and applying a slot profile already exists
@@ -27,7 +27,6 @@
  * need it, and it is pure data + pure functions on plain objects.
  */
 import { type MeshTaskDifficulty, type NodeCapabilitySlot } from './brain-routing';
-import type { MagiSlot } from './magi';
 /**
  * One provider's seeded slot recipe. A provider may map to MORE THAN ONE slot
  * (claude-cli does: a wide sonnet slot plus a narrow opus slot for the hard
@@ -120,28 +119,3 @@ export interface SlotProposal {
  * returned proposal can report what a wholesale write would destroy.
  */
 export declare function buildSlotProposal(detected: readonly DetectedCliProvider[], currentSlots?: readonly NodeCapabilitySlot[]): SlotProposal;
-/**
- * Build a MAGI panel proposal from the same detections.
- *
- * ─── Deliberately narrow ──────────────────────────────────────────────────────
- *
- * MAGI's value is provider INDEPENDENCE: replicas from different providers
- * (ideally different machines) answering the same question, so agreement means
- * something. Detection tells us which providers exist — that is exactly enough
- * to propose one panel of distinct providers, and no more.
- *
- * What detection does NOT tell us is which provider suits which review KIND
- * (rca vs design vs claim_audit). Nothing in any manifest grades a provider for
- * root-cause analysis over design review, and inventing a per-kind assignment
- * would fabricate a rationale that does not exist. So this proposes ONE panel of
- * the detected providers and leaves the kind binding to the operator; the caller
- * decides which `task_kind` to bind it to via the existing dry-run tool.
- *
- * Ordering follows {@link CLI_SLOT_RECIPES} insertion order (recipe-known
- * providers first, in table order), so the panel leads with the providers whose
- * suitability is actually attested.
- */
-export declare function buildMagiPanelProposal(detected: readonly DetectedCliProvider[], opts?: {
-    nodeId?: string;
-    maxSlots?: number;
-}): MagiSlot[];

package/dist/turn-ipc-guards.d.ts

@@ -0,0 +1,18 @@
+/**
+ * turn-ipc shared runtime-guard primitives (the protocol version stamp and the
+ * small structural checks every command decoder composes). Part of the turn-ipc
+ * wire contract (./turn-ipc.ts).
+ */
+/** Every request in this file is versioned so a responder can reject a shape it predates. */
+export declare const TURN_IPC_PROTOCOL_VERSION: 1;
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function isNonNegativeInt(value: unknown): value is number;
+export declare function isOptionalId(value: unknown): boolean;
+export declare function hasOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean;
+export declare function makeGuard<T extends readonly string[]>(values: T): (value: unknown) => value is T[number];
+export declare function isStringArray(value: unknown): value is readonly string[];
+export declare function isOptionalShortString(value: unknown, max?: number): boolean;
+export declare function isRecordArray(value: unknown): value is readonly Record<string, unknown>[];
+export declare function isOptionalRecord(value: unknown): boolean;
+export declare function isOptionalBoolean(value: unknown): boolean;
+export declare function isOptionalString(value: unknown): boolean;

package/dist/turn-ipc-mission.d.ts

@@ -0,0 +1,250 @@
+/**
+ * turn-ipc — mission, note, tool-call and ledger commands: mission_upsert,
+ * mission_query, mission_list_query, note_upsert, note_forget, tool_call_record,
+ * ledger_query. Part of the turn-ipc wire contract (./turn-ipc.ts).
+ */
+import { TURN_IPC_PROTOCOL_VERSION } from './turn-ipc-guards';
+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 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;
+    /**
+     * 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;
+    /** H2: absent = no brief attached to this mission. */
+    brief?: MissionBriefWire;
+}
+export interface MissionUpsertResponse {
+    mission: MeshMissionRecordWire;
+}
+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 decodeMissionQueryRequest(value: unknown): MissionQueryRequest | null;
+export declare function decodeMissionQueryResponse(value: unknown): MissionQueryResponse | null;
+export interface MissionListQueryRequest {
+    v: typeof TURN_IPC_PROTOCOL_VERSION;
+    meshId: string;
+    statuses?: readonly MeshMissionStatusValue[];
+    verbose?: boolean;
+    withStats?: boolean;
+    limit?: number;
+    historyIdLimit?: number;
+    /**
+     * The mesh_status mission projection, computed in the daemon (the MCP no longer
+     * opens the daemon's store for it): 'compact' = `getMeshStatusMissionsCompact`
+     * (live missions goal-elided + folded history), 'verbose' =
+     * `getMeshStatusMissionSummaries({verbose: true})` (live + capped history, full
+     * goal, no stats — stats ride one batched `task_stats_query`). Rows then also
+     * carry `createdAt`/`updatedAt`/`closeCandidateEmittedAt`. When set, every other
+     * option except `historyIdLimit` is ignored. An older daemon rejects the key.
+     */
+    meshStatusView?: 'compact' | 'verbose';
+}
+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;
+    tasks: MeshMissionTaskAggregateWire;
+    stats?: MeshMissionStatsWire;
+    /** H2: absent = no brief attached. */
+    brief?: MissionBriefWire;
+    /** `meshStatusView` rows only. */
+    createdAt?: string;
+    updatedAt?: string;
+    closeCandidateEmittedAt?: string | null;
+}
+/** Compact (default) mission row. `goalPreview`/`goalTruncated` present, `goal` absent. */
+export interface MissionListSummarySlimWire {
+    id: string;
+    meshId: string;
+    title: string;
+    goalPreview: string;
+    goalTruncated: boolean;
+    status: MeshMissionStatusValue;
+    tasks: MeshMissionTaskAggregateWire;
+    stats?: MeshMissionStatsWire;
+    /** H2: absent = no brief attached. */
+    brief?: MissionBriefWire;
+    /** `meshStatusView` rows only. */
+    createdAt?: string;
+    updatedAt?: string;
+    closeCandidateEmittedAt?: string | null;
+}
+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 decodeMissionListQueryRequest(value: unknown): MissionListQueryRequest | null;
+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 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 decodeNoteUpsertRequest(value: unknown): NoteUpsertRequest | null;
+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 decodeNoteForgetRequest(value: unknown): NoteForgetRequest | null;
+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 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 decodeToolCallRecordRequest(value: unknown): ToolCallRecordRequest | null;
+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 decodeLedgerQueryRequest(value: unknown): LedgerQueryRequest | null;
+export declare function decodeLedgerQueryResponse(value: unknown): LedgerQueryResponse | null;