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

package/src/turn-ipc-queue.ts

@@ -1,7 +1,7 @@
 /**
  * turn-ipc — local records, queue composites and active work (C-W9a):
- * record_local, queue_query, queue_enqueue, queue_enqueue_graph, queue_cancel,
- * queue_requeue, direct_dispatch_record, graph_audit_record, active_work_query,
+ * record_local, queue_query, queue_enqueue, queue_enqueue_batch, queue_cancel,
+ * queue_requeue, direct_dispatch_record, active_work_query,
  * recovery_context_query. Part of the turn-ipc wire contract (./turn-ipc.ts).
  */
 
@@ -16,7 +16,7 @@
 //
 // CONTENT BOUNDARY: like `mission_upsert`'s `goal`, `note_upsert`'s `text` and
 // `ledger_query`'s entry payloads, several fields here are free text or
-// unbounded JSON (a task message, a MAGI synthesis, a queue row with its
+// unbounded JSON (a task message, a queue row with its
 // message, an active-work record with its task summary). This is fine for the
 // same reason: local IPC between the mcp-server and the daemon on the
 // operator's own machine — never a cross-machine or server hop. Those fields
@@ -36,7 +36,6 @@ import {
     isOptionalRecord,
     isRecordArray,
     isOptionalString,
-    makeGuard,
 } from './turn-ipc-guards';
 
 /** A queue row as the daemon's `getQueue` returns it — a JSON passthrough (see the section note). */
@@ -51,7 +50,7 @@ function isQueueEntryWire(value: unknown): value is QueueEntryWire {
 // `meshRecord(meshId, kind, scalars, { local: true })` over IPC: the scalar
 // projection goes to `mesh.<id>.events` (content-free), the FULL payload lands
 // in the daemon's `mesh_local_records` (local-only). Replaces every mcp-server
-// `appendLedgerEntry` (dispatch / MAGI question+synthesis / checkpoint message /
+// `appendLedgerEntry` (dispatch / checkpoint message /
 // reconcile records). `payload` is free-form JSON (see the section note).
 
 export interface RecordLocalRequest {
@@ -116,7 +115,7 @@ export interface QueueQueryRequest {
     /** With `withCounts`: also count terminal rows whose `updated_at` is older than this age. */
     historicalOlderThanMs?: number
     /**
-     * Also return `dependencyHeads`: id/status/blockedReason/cancelReason of every
+     * Also return `dependencyHeads`: id/status/cancelReason of every
      * row the returned entries list in `dependsOn` that is not itself returned —
      * enough to annotate dependency state without reading the whole queue.
      */
@@ -127,7 +126,6 @@ export interface QueueQueryRequest {
 export interface QueueDependencyHeadWire {
     id: string
     status: string
-    blockedReason?: string
     cancelReason?: string
 }
 
@@ -155,9 +153,8 @@ export function decodeQueueQueryRequest(value: unknown): QueueQueryRequest | nul
 }
 
 function isQueueDependencyHeadWire(value: unknown): value is QueueDependencyHeadWire {
-    return isRecord(value) && hasOnlyKeys(value, ['id', 'status', 'blockedReason', 'cancelReason'])
+    return isRecord(value) && hasOnlyKeys(value, ['id', 'status', 'cancelReason'])
         && typeof value.id === 'string' && typeof value.status === 'string'
-        && (value.blockedReason === undefined || typeof value.blockedReason === 'string')
         && (value.cancelReason === undefined || typeof value.cancelReason === 'string')
 }
 
@@ -176,9 +173,8 @@ export function decodeQueueQueryResponse(value: unknown): QueueQueryResponse | n
 
 // ── queue_enqueue ──
 //
-// `enqueueTask(meshId, message, options)` + (when `decision` is given) the
-// single-surface `recordSingleEnqueueDecision` for the new task id, in the
-// daemon. `options` is `MeshEnqueueTaskOptions` (daemon-core) as a JSON
+// `enqueueTask(meshId, message, options)` in the daemon. `options` is
+// `MeshEnqueueTaskOptions` (daemon-core) as a JSON
 // passthrough; the daemon's enqueue guards (message, task-mode, difficulty,
 // dependency cycle) run unchanged and a refusal comes back as the error.
 
@@ -188,8 +184,6 @@ export interface QueueEnqueueRequest {
     /** 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 {
@@ -197,10 +191,10 @@ export interface QueueEnqueueResponse {
 }
 
 function isQueueEnqueueRequest(value: unknown): value is QueueEnqueueRequest {
-    return isRecord(value) && hasOnlyKeys(value, ['v', 'meshId', 'message', 'options', 'decision'])
+    return isRecord(value) && hasOnlyKeys(value, ['v', 'meshId', 'message', 'options'])
         && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId)
         && typeof value.message === 'string'
-        && isOptionalRecord(value.options) && isOptionalRecord(value.decision)
+        && isOptionalRecord(value.options)
 }
 
 export function decodeQueueEnqueueRequest(value: unknown): QueueEnqueueRequest | null {
@@ -215,53 +209,41 @@ export function decodeQueueEnqueueResponse(value: unknown): QueueEnqueueResponse
     return isQueueEnqueueResponse(value) ? value : null
 }
 
-// ── queue_enqueue_graph ──
+// ── queue_enqueue_batch ──
 //
-// The atomic batch enqueue, both paths, with its audit trail — in the daemon:
-//   - `mode: 'compat'` → `enqueueTaskGraph(meshId, specs)`;
-//   - `mode: 'graph'`  → `commitMeshGraphPlan(plan)` + `recordGraphEnqueueCommitted`.
-// A failure records `recordGraphEnqueueRolledBack` (graph) or
-// `recordGraphEnqueueValidationFailed` (compat) from the catch — the daemon
-// writes the audit AFTER the failed transaction, exactly as design :752-753
-// requires — and answers `{ ok: false, refusalCode?, message, extra? }` (a
-// domain refusal is a RESULT here, not a transport error, so the caller keeps
-// its code/extra for the tool response). NOT `code`/`error`: those two keys
-// belong to the command envelope (`{ success, error, code }`) the client
-// unwraps, so a result must never reuse them.
-
-export interface QueueEnqueueGraphRequest {
+// The atomic multi-task enqueue in the daemon: `enqueueTaskBatch(meshId, specs)`
+// — every task inserts or none does. A refusal answers
+// `{ ok: false, refusalCode?, message, extra? }` (a domain refusal is a RESULT
+// here, not a transport error, so the caller keeps its code/extra for the tool
+// response). NOT `code`/`error`: those two keys belong to the command envelope
+// (`{ success, error, code }`) the client unwraps, so a result must never
+// reuse them.
+
+export interface QueueEnqueueBatchRequest {
     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>
+    /** `MeshTaskBatchEntrySpec[]` (daemon-core, JSON passthrough). */
+    specs: readonly Record<string, unknown>[]
 }
 
-export type QueueEnqueueGraphResponse =
-    | { ok: true; tasks: readonly QueueEntryWire[]; graph?: Record<string, unknown> }
+export type QueueEnqueueBatchResponse =
+    | { ok: true; tasks: readonly QueueEntryWire[] }
     | { ok: false; refusalCode?: string; message: string; extra?: Record<string, unknown> }
 
-function isQueueEnqueueGraphRequest(value: unknown): value is QueueEnqueueGraphRequest {
-    if (!isRecord(value) || !hasOnlyKeys(value, ['v', 'meshId', 'mode', 'specs', 'plan', 'audit'])) return false
-    if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false
-    if (value.mode === 'compat') return isRecordArray(value.specs) && value.plan === undefined && isOptionalRecord(value.audit)
-    if (value.mode === 'graph') return isRecord(value.plan) && value.specs === undefined && isOptionalRecord(value.audit)
-    return false
+function isQueueEnqueueBatchRequest(value: unknown): value is QueueEnqueueBatchRequest {
+    return isRecord(value) && hasOnlyKeys(value, ['v', 'meshId', 'specs'])
+        && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId)
+        && isRecordArray(value.specs)
 }
 
-export function decodeQueueEnqueueGraphRequest(value: unknown): QueueEnqueueGraphRequest | null {
-    return isQueueEnqueueGraphRequest(value) ? value : null
+export function decodeQueueEnqueueBatchRequest(value: unknown): QueueEnqueueBatchRequest | null {
+    return isQueueEnqueueBatchRequest(value) ? value : null
 }
 
-function isQueueEnqueueGraphResponse(value: unknown): value is QueueEnqueueGraphResponse {
+function isQueueEnqueueBatchResponse(value: unknown): value is QueueEnqueueBatchResponse {
     if (!isRecord(value)) return false
     if (value.ok === true) {
-        return hasOnlyKeys(value, ['ok', 'tasks', 'graph']) && Array.isArray(value.tasks) && value.tasks.every(isQueueEntryWire)
-            && isOptionalRecord(value.graph)
+        return hasOnlyKeys(value, ['ok', 'tasks']) && Array.isArray(value.tasks) && value.tasks.every(isQueueEntryWire)
     }
     if (value.ok === false) {
         return hasOnlyKeys(value, ['ok', 'refusalCode', 'message', 'extra']) && typeof value.message === 'string'
@@ -270,8 +252,8 @@ function isQueueEnqueueGraphResponse(value: unknown): value is QueueEnqueueGraph
     return false
 }
 
-export function decodeQueueEnqueueGraphResponse(value: unknown): QueueEnqueueGraphResponse | null {
-    return isQueueEnqueueGraphResponse(value) ? value : null
+export function decodeQueueEnqueueBatchResponse(value: unknown): QueueEnqueueBatchResponse | null {
+    return isQueueEnqueueBatchResponse(value) ? value : null
 }
 
 // ── queue_cancel ──
@@ -347,9 +329,8 @@ export function decodeQueueRequeueResponse(value: unknown): QueueRequeueResponse
 //
 // The post-dispatch bookkeeping of `mesh_send_task`'s direct arms, in the
 // daemon: `recordDirectDispatchTask` (materialise the queue row, stamped with
-// the already-open `mesh_direct` attempt) and `recordDirectDispatchDecision`
-// (GRAPH-MEASUREMENT-DIRECT). Each step is best-effort and reported separately
-// — a dispatch that already happened must never fail on its bookkeeping.
+// the already-open `mesh_direct` attempt). Best-effort and reported — a
+// dispatch that already happened must never fail on its bookkeeping.
 
 export interface DirectDispatchRecordRequest {
     v: typeof TURN_IPC_PROTOCOL_VERSION
@@ -359,19 +340,16 @@ export interface DirectDispatchRecordRequest {
     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
 }
 
 function isDirectDispatchRecordRequest(value: unknown): value is DirectDispatchRecordRequest {
-    return isRecord(value) && hasOnlyKeys(value, ['v', 'meshId', 'taskId', 'message', 'task', 'decision'])
+    return isRecord(value) && hasOnlyKeys(value, ['v', 'meshId', 'taskId', 'message', 'task'])
         && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.taskId)
-        && typeof value.message === 'string' && isOptionalRecord(value.task) && isOptionalRecord(value.decision)
+        && typeof value.message === 'string' && isOptionalRecord(value.task)
 }
 
 export function decodeDirectDispatchRecordRequest(value: unknown): DirectDispatchRecordRequest | null {
@@ -379,54 +357,14 @@ export function decodeDirectDispatchRecordRequest(value: unknown): DirectDispatc
 }
 
 function isDirectDispatchRecordResponse(value: unknown): value is DirectDispatchRecordResponse {
-    return isRecord(value) && hasOnlyKeys(value, ['taskRecorded', 'decisionRecorded'])
-        && typeof value.taskRecorded === 'boolean' && typeof value.decisionRecorded === 'boolean'
+    return isRecord(value) && hasOnlyKeys(value, ['taskRecorded'])
+        && typeof value.taskRecorded === 'boolean'
 }
 
 export function decodeDirectDispatchRecordResponse(value: unknown): DirectDispatchRecordResponse | null {
     return isDirectDispatchRecordResponse(value) ? value : null
 }
 
-// ── graph_audit_record ──
-//
-// The coordinator-gate / node-patch provenance records the `mesh_graph_*`
-// tools write after a gate action (design :740-750), written by the daemon's
-// allow-listed recorders (mesh-graph-provenance.ts) — the mcp-server never
-// builds the record payload itself. `fields` is the recorder's argument object.
-
-export const GRAPH_AUDIT_EVENTS = ['gate_claimed', 'gate_released', 'gate_abandoned', 'node_patched'] as const
-export type GraphAuditEvent = typeof GRAPH_AUDIT_EVENTS[number]
-const isGraphAuditEvent = makeGuard(GRAPH_AUDIT_EVENTS)
-
-export interface GraphAuditRecordRequest {
-    v: typeof TURN_IPC_PROTOCOL_VERSION
-    meshId: string
-    event: GraphAuditEvent
-    fields: Record<string, unknown>
-}
-
-export interface GraphAuditRecordResponse {
-    recorded: boolean
-}
-
-function isGraphAuditRecordRequest(value: unknown): value is GraphAuditRecordRequest {
-    return isRecord(value) && hasOnlyKeys(value, ['v', 'meshId', 'event', 'fields'])
-        && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId)
-        && isGraphAuditEvent(value.event) && isRecord(value.fields)
-}
-
-export function decodeGraphAuditRecordRequest(value: unknown): GraphAuditRecordRequest | null {
-    return isGraphAuditRecordRequest(value) ? value : null
-}
-
-function isGraphAuditRecordResponse(value: unknown): value is GraphAuditRecordResponse {
-    return isRecord(value) && hasOnlyKeys(value, ['recorded']) && typeof value.recorded === 'boolean'
-}
-
-export function decodeGraphAuditRecordResponse(value: unknown): GraphAuditRecordResponse | null {
-    return isGraphAuditRecordResponse(value) ? value : null
-}
-
 // ── active_work_query ──
 //
 // The active-work view, COMPUTED in the daemon: it reads the queue, the open

package/src/turn-ipc-stats.ts

@@ -0,0 +1,193 @@
+/**
+ * turn-ipc — task stats and maintenance commands: task_stats_query,
+ * prune_stale_direct, orphaned_pin_notify. Part of the turn-ipc wire contract
+ * (./turn-ipc.ts).
+ */
+
+import {
+    TURN_IPC_PROTOCOL_VERSION,
+    hasOnlyKeys,
+    isOptionalBoolean,
+    isOptionalRecord,
+    isNonNegativeInt,
+    isRecordArray,
+} from './turn-ipc-guards';
+import { isRecord } from './protocol/envelope';
+import { isEvidenceIdentifier } from './turn-evidence';
+
+// ─── task_stats_query ───────────────────────────────────────────────────────
+//
+// C-W9c: replaces the in-process `computeMeshTaskStats` / `computeMeshMissionStats`
+// (daemon-core `mesh-task-stats.ts`) — both scan the daemon's queue + local
+// records, so both move behind one command. Exactly one of `taskIds` /
+// `missionId` selects the per-task mode; `missionId` alone with `rollup: true`
+// additionally returns the mission-level aggregate.
+
+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
+    /**
+     * Batch rollups: `computeMeshMissionStats` for every id, over ONE queue read and
+     * ONE record read (answers `missions`, `tasks` empty). Exclusive with
+     * `taskIds`/`missionId`. An older daemon rejects the key.
+     */
+    missionIds?: readonly string[]
+}
+
+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>
+    /** Batch mode: `MeshMissionStats` per requested mission id, JSON passthrough. */
+    missions?: Record<string, Record<string, unknown>>
+}
+
+function isTaskStatsQueryRequest(value: unknown): value is TaskStatsQueryRequest {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['v', 'meshId', 'taskIds', 'missionId', 'tail', 'rollup', 'missionIds'])) return false
+    if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false
+    if (value.taskIds !== undefined) {
+        if (!Array.isArray(value.taskIds) || value.taskIds.length === 0 || !value.taskIds.every(isEvidenceIdentifier)) return false
+    }
+    if (value.missionId !== undefined && !isEvidenceIdentifier(value.missionId)) return false
+    if (value.tail !== undefined && !isNonNegativeInt(value.tail)) return false
+    if (value.missionIds !== undefined) {
+        if (!Array.isArray(value.missionIds) || value.missionIds.length === 0 || !value.missionIds.every(isEvidenceIdentifier)) return false
+        if (value.taskIds !== undefined || value.missionId !== undefined) return false
+    }
+    if (value.rollup === true && value.missionId === undefined) return false
+    return isOptionalBoolean(value.rollup)
+}
+
+export function decodeTaskStatsQueryRequest(value: unknown): TaskStatsQueryRequest | null {
+    return isTaskStatsQueryRequest(value) ? value : null
+}
+
+function isTaskStatsQueryResponse(value: unknown): value is TaskStatsQueryResponse {
+    return isRecord(value) && hasOnlyKeys(value, ['tasks', 'mission', 'missions']) && isRecordArray(value.tasks) && isOptionalRecord(value.mission)
+        && (value.missions === undefined || (isRecord(value.missions) && Object.values(value.missions).every(isRecord)))
+}
+
+export function decodeTaskStatsQueryResponse(value: unknown): TaskStatsQueryResponse | null {
+    return isTaskStatsQueryResponse(value) ? value : null
+}
+
+// ─── prune_stale_direct ─────────────────────────────────────────────────────
+//
+// C-W9c: replaces the in-process `pruneStaleDirectDispatches` call
+// (`mesh_cleanup_sessions` mode=prune_stale_direct, `mesh-tools-session.ts`). Unlike the other
+// C-W9 commands this one does NOT take its inputs (queue/records/direct
+// dispatches) on the wire — the daemon already reads them itself
+// (`getQueue`/`readLocalRecords`/`getActiveDirectDispatches`), so the request
+// carries only the decision knobs. `closeDispatches` (the C-W8 `turn_cancel`
+// callback) also runs daemon-side now, since it is the same process.
+
+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>[]
+}
+
+function isPruneStaleDirectRequest(value: unknown): value is PruneStaleDirectRequest {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['v', 'meshId', 'execute', 'includeTerminal', 'source'])) return false
+    if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false
+    if (value.source !== undefined && typeof value.source !== 'string') return false
+    return isOptionalBoolean(value.execute) && isOptionalBoolean(value.includeTerminal)
+}
+
+export function decodePruneStaleDirectRequest(value: unknown): PruneStaleDirectRequest | null {
+    return isPruneStaleDirectRequest(value) ? value : null
+}
+
+function isPruneStaleDirectResponse(value: unknown): value is PruneStaleDirectResponse {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['mode', 'includeTerminal', 'candidateCount', 'prunable', 'prunedCount', 'preservedUnacknowledged', 'preservedLedgerOnly', 'preservedNotOrphan'])) return false
+    if (value.mode !== 'execute' && value.mode !== 'dry_run') return false
+    if (typeof value.includeTerminal !== 'boolean') return false
+    if (!isNonNegativeInt(value.candidateCount) || !isNonNegativeInt(value.prunedCount)) return false
+    return isRecordArray(value.prunable) && isRecordArray(value.preservedUnacknowledged)
+        && isRecordArray(value.preservedLedgerOnly) && isRecordArray(value.preservedNotOrphan)
+}
+
+export function decodePruneStaleDirectResponse(value: unknown): PruneStaleDirectResponse | null {
+    return isPruneStaleDirectResponse(value) ? value : null
+}
+
+// ─── orphaned_pin_notify ────────────────────────────────────────────────────
+//
+// C-W9c: replaces the in-process `notifyCoordinatorOfOrphanedPins` call
+// (`mesh_queue_cancel` tool, `mesh-tools-queue.ts`, CANCEL-ORPHANS-PINNED-TASK).
+// The core reads the daemon's live queue (`getQueue`) and, when it finds
+// orphans, calls `notifyMeshCoordinator` to page the coordinator — both are
+// daemon-only concerns, so the whole call moves, not just its queue read.
+// `title` is a task-message-derived label (first line, truncated) — free text,
+// hence local IPC only, same rationale as `record_local`'s payload.
+
+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[]
+}
+
+function isOrphanedPinnedTaskWire(value: unknown): value is OrphanedPinnedTaskWire {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['taskId', 'title', 'targetSessionId', 'targetNodeId', 'missionId'])) return false
+    if (!isEvidenceIdentifier(value.taskId) || !isEvidenceIdentifier(value.targetSessionId)) return false
+    if (typeof value.title !== 'string') return false
+    if (value.targetNodeId !== undefined && !isEvidenceIdentifier(value.targetNodeId)) return false
+    return value.missionId === undefined || isEvidenceIdentifier(value.missionId)
+}
+
+function isOrphanedPinNotifyRequest(value: unknown): value is OrphanedPinNotifyRequest {
+    if (!isRecord(value) || !hasOnlyKeys(value, ['v', 'meshId', 'stoppedSessionId', 'excludeTaskId', 'cause', 'nodeId', 'coordinatorSessionId'])) return false
+    if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId) || !isEvidenceIdentifier(value.stoppedSessionId)) return false
+    if (value.excludeTaskId !== undefined && !isEvidenceIdentifier(value.excludeTaskId)) return false
+    if (value.cause !== undefined && typeof value.cause !== 'string') return false
+    if (value.nodeId !== undefined && !isEvidenceIdentifier(value.nodeId)) return false
+    return value.coordinatorSessionId === undefined || isEvidenceIdentifier(value.coordinatorSessionId)
+}
+
+export function decodeOrphanedPinNotifyRequest(value: unknown): OrphanedPinNotifyRequest | null {
+    return isOrphanedPinNotifyRequest(value) ? value : null
+}
+
+function isOrphanedPinNotifyResponse(value: unknown): value is OrphanedPinNotifyResponse {
+    return isRecord(value) && hasOnlyKeys(value, ['orphans']) && Array.isArray(value.orphans) && value.orphans.every(isOrphanedPinnedTaskWire)
+}
+
+export function decodeOrphanedPinNotifyResponse(value: unknown): OrphanedPinNotifyResponse | null {
+    return isOrphanedPinNotifyResponse(value) ? value : null
+}

package/src/turn-ipc.ts

@@ -52,7 +52,7 @@
  * LAYOUT
  * -------
  * This module holds the error codes and the command registry; the per-command
- * contracts live in ./turn-ipc-{turn,mission,queue,graph}.ts (re-exported here)
+ * contracts live in ./turn-ipc-{turn,mission,queue,stats}.ts (re-exported here)
  * over the shared guard primitives in ./turn-ipc-guards.ts.
  */
 
@@ -63,7 +63,7 @@ export { TURN_IPC_PROTOCOL_VERSION } from './turn-ipc-guards';
 export * from './turn-ipc-turn';
 export * from './turn-ipc-mission';
 export * from './turn-ipc-queue';
-export * from './turn-ipc-graph';
+export * from './turn-ipc-stats';
 
 // ─── error codes ────────────────────────────────────────────────────────────
 
@@ -120,21 +120,15 @@ export const TURN_IPC_COMMANDS = [
     'record_local',
     'queue_query',
     'queue_enqueue',
-    'queue_enqueue_graph',
+    'queue_enqueue_batch',
     'queue_cancel',
     'queue_requeue',
     'direct_dispatch_record',
-    'graph_audit_record',
     'active_work_query',
     'recovery_context_query',
     // C-W9c additions (2026-09-24 19:00 stamp — the last mcp-server in-process
-    // daemon-core paths: graph gates/plan/patch, mission reads (MAGI), task/
-    // mission stats, orphaned-pin helpers, one prune audit):
-    'graph_gate_claim',
-    'graph_gate_release',
-    'graph_gate_abandon',
-    'graph_node_patch',
-    'graph_view_query',
+    // daemon-core paths: mission reads, task/mission stats, orphaned-pin
+    // helpers, one prune audit):
     'task_stats_query',
     'prune_stale_direct',
     'orphaned_pin_notify',