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

package/src/release.ts

@@ -0,0 +1,121 @@
+/**
+ * release — types, limits and pure helpers for release objects
+ * (docs/design/2026-11-01-release-objects.md).
+ *
+ * A release is a mesh-scoped entity that groups MISSIONS (explicit membership) and records
+ * deploy facts. It is distinct from the vendor release stamp (a build channel stamp) and
+ * from `.adhdev/preview-deploy.json` (the per-checkout deploy record it snapshots).
+ * Membership is only ever created by an explicit call; git evaluation and deploy heads
+ * produce suggestions, never members. Dependency-free leaf.
+ */
+
+export const MESH_RELEASE_CHANNELS = ['preview', 'stable'] as const
+export type MeshReleaseChannel = typeof MESH_RELEASE_CHANNELS[number]
+export function isMeshReleaseChannel(value: unknown): value is MeshReleaseChannel {
+    return typeof value === 'string' && (MESH_RELEASE_CHANNELS as readonly string[]).includes(value)
+}
+
+export const MESH_RELEASE_STATUSES = ['planned', 'frozen', 'deployed', 'verified', 'superseded', 'cancelled'] as const
+export type ReleaseStatus = typeof MESH_RELEASE_STATUSES[number]
+export function isReleaseStatus(value: unknown): value is ReleaseStatus {
+    return typeof value === 'string' && (MESH_RELEASE_STATUSES as readonly string[]).includes(value)
+}
+
+export const RELEASE_MEMBER_STATES = ['member', 'moved_out', 'removed'] as const
+export type ReleaseMemberState = typeof RELEASE_MEMBER_STATES[number]
+
+/** Who may write release membership. The daemon never adds a member on its own. */
+export const RELEASE_ACTORS = ['coordinator', 'owner', 'assistant', 'script'] as const
+export type ReleaseActor = typeof RELEASE_ACTORS[number]
+
+export const RELEASE_EVENT_TYPES = [
+    'created', 'status_changed', 'scope_added', 'scope_moved', 'scope_removed',
+    'deploy_recorded', 'changelog_drafted', 'changelog_applied',
+] as const
+export type ReleaseEventType = typeof RELEASE_EVENT_TYPES[number]
+
+/** Mission-side events recorded when membership changes (so the mission history shows it). */
+export const MISSION_RELEASE_EVENT_TYPES = ['release_attached', 'release_moved', 'release_detached'] as const
+
+export const RELEASE_LIMITS = {
+    name: 80,
+    note: 500,
+    /** `mesh_missions.release_note`: one user/operator-visible sentence. */
+    releaseNote: 400,
+    missionsPerCall: 100,
+    changelogEntries: 300,
+} as const
+
+/** Deploy targets snapshot (a copy of `.adhdev/preview-deploy.json` `targets`). */
+export interface ReleaseDeployTarget {
+    commit?: string
+    deployedAt?: string
+    previewVersion?: string
+    [key: string]: unknown
+}
+export type ReleaseTargets = Partial<Record<'npm' | 'server' | 'web', ReleaseDeployTarget>> & Record<string, ReleaseDeployTarget | undefined>
+
+export const CHANGELOG_SECTIONS = ['Added', 'Fixed', 'Changed'] as const
+export type ChangelogSection = typeof CHANGELOG_SECTIONS[number]
+
+export interface ChangelogDraftEntry {
+    missionId: string
+    /** `<!-- m:<id8> -->` — the idempotency marker `--apply` writes after the line. */
+    marker: string
+    section: ChangelogSection
+    /** The sentence that would be written to CHANGELOG.md. */
+    text: string
+    source: 'release_note' | 'summary'
+    /** True when `text` is not user-facing wording yet (carries the needs-wording marker). */
+    needsWording?: boolean
+    /** Evidence kept in the draft JSON only; never written to CHANGELOG.md. */
+    evidence?: { gitState?: string; outcome?: string; shas?: string[] }
+    /** Non-blocking lint warnings (internal ids / wave numbers / forbidden phrases). */
+    lint?: string[]
+}
+
+export interface ChangelogDraftExcluded {
+    missionId: string
+    reason: string
+}
+
+export interface ChangelogDraft {
+    generatedAt: string
+    entries: ChangelogDraftEntry[]
+    /** Member missions without a `release_note` (target 0 at deploy time). */
+    needsNote: string[]
+    excluded: ChangelogDraftExcluded[]
+    /** Member missions whose refs are not confirmed on the default branch (`not_landed` / `unknown`). */
+    warnings: Array<{ missionId: string; gitState: string; message: string }>
+    appliedAt?: string
+}
+
+export const NEEDS_WORDING_MARKER = '[needs user-facing wording]'
+
+/** Marker that makes `--apply` idempotent: one per mission entry inside CHANGELOG.md. */
+export function changelogMissionMarker(missionId: string): string {
+    return `<!-- m:${missionId.slice(0, 8)} -->`
+}
+
+/** Default section for an entry; `[Fixed]`/`[Added]`/`[Changed]` prefixes on the note pin it. */
+export function classifyChangelogSection(text: string, hint?: string): { section: ChangelogSection; text: string } {
+    const m = /^\s*\[(added|fixed|changed)\]\s*/i.exec(text)
+    if (m) {
+        const key = m[1].toLowerCase()
+        return { section: key === 'added' ? 'Added' : key === 'fixed' ? 'Fixed' : 'Changed', text: text.slice(m[0].length).trim() }
+    }
+    const probe = `${hint ?? ''} ${text}`.toLowerCase()
+    if (/\b(fix|fixes|fixed|bug|regression|crash|error)\b|오류|결함|버그|수정/.test(probe)) return { section: 'Fixed', text }
+    if (/\b(add|adds|added|new|introduc\w*|support\w*)\b|신규|추가/.test(probe)) return { section: 'Added', text }
+    return { section: 'Changed', text }
+}
+
+/** Phrases that must not reach a public CHANGELOG (internal waves, rc numbering, ids). Warning-only. */
+export function lintChangelogText(text: string): string[] {
+    const out: string[] = []
+    if (/\bwave[\s-]*\d+/i.test(text) || /웨이브\s*\d+/.test(text)) out.push('mentions an internal wave number')
+    if (/\brc[.\s-]?\d+\b/i.test(text)) out.push('mentions an internal rc number')
+    if (/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i.test(text) || /\bmi_[0-9a-f]{12}\b/.test(text) || /\brel_[0-9a-f]{12}\b/.test(text)) out.push('contains an internal id')
+    if (/\bmission\b/i.test(text)) out.push('mentions "mission" (internal vocabulary)')
+    return out
+}

package/src/role-launch.ts

@@ -0,0 +1,51 @@
+/** Persisted role-launch intent. Restart replays this selection rather than
+ * consulting newer machine defaults; restore preserves its original provenance. */
+import { isLaunchDefaultRole, isLaunchDefaultSource, type LaunchDefaultRole,
+    type LaunchDefaultSelection, type LaunchDefaultAxis, type LaunchDefaultRef } from './launch-defaults';
+export interface RoleLaunchSelection {
+    role: LaunchDefaultRole;
+    selection: LaunchDefaultSelection;
+    applied: Record<keyof LaunchDefaultSelection, LaunchDefaultAxis>;
+    defaultRef?: LaunchDefaultRef;
+    documentRevision: number;
+}
+function record(value: unknown): Record<string, unknown> | undefined {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown> : undefined;
+}
+function ref(value: unknown): LaunchDefaultRef | undefined {
+    const r = record(value);
+    if (!r || !isLaunchDefaultRole(r.role) || (r.scope !== 'global' && r.scope !== 'project')
+        || !Number.isSafeInteger(r.revision) || (r.revision as number) < 1
+        || (r.scope === 'project' && (typeof r.projectId !== 'string' || !r.projectId))) return undefined;
+    return { role: r.role, scope: r.scope, revision: r.revision as number,
+        ...(r.scope === 'project' ? { projectId: r.projectId as string } : {}) };
+}
+function axis(value: unknown): LaunchDefaultAxis | undefined {
+    const a = record(value);
+    if (!a || !isLaunchDefaultSource(a.source) || (a.value !== null && typeof a.value !== 'string')) return undefined;
+    const defaultRef = ref(a.defaultRef);
+    if (a.source === 'stored_default' && defaultRef?.scope !== 'global'
+        || a.source === 'project_default' && defaultRef?.scope !== 'project'
+        || (a.source === 'user' || a.source === 'provider_default') && a.defaultRef !== undefined) return undefined;
+    return { value: a.value as string | null, source: a.source, ...(defaultRef ? { defaultRef } : {}) };
+}
+export function parseRoleLaunchSelection(value: unknown): RoleLaunchSelection | undefined {
+    const r = record(value), s = record(r?.selection), a = record(r?.applied);
+    if (!r || !isLaunchDefaultRole(r.role) || !s || typeof s.provider !== 'string' || !s.provider
+        || !Number.isSafeInteger(r.documentRevision) || (r.documentRevision as number) < 1
+        || (s.model !== undefined && typeof s.model !== 'string')
+        || (s.thinkingLevel !== undefined && typeof s.thinkingLevel !== 'string')) return undefined;
+    const provider = axis(a?.provider), model = axis(a?.model), thinkingLevel = axis(a?.thinkingLevel);
+    if (!provider || !model || !thinkingLevel
+        || [provider, model, thinkingLevel].some(axis => axis.defaultRef && (axis.defaultRef.role !== r.role
+            || axis.defaultRef.scope === 'global' && axis.defaultRef.revision > (r.documentRevision as number)))
+        || provider.value !== s.provider
+        || model.value !== (s.model ?? null) || thinkingLevel.value !== (s.thinkingLevel ?? null)) return undefined;
+    const defaultRef = ref(r.defaultRef);
+    return { role: r.role, selection: { provider: s.provider,
+        ...(typeof s.model === 'string' ? { model: s.model } : {}),
+        ...(typeof s.thinkingLevel === 'string' ? { thinkingLevel: s.thinkingLevel } : {}) },
+        applied: { provider, model, thinkingLevel }, ...(defaultRef ? { defaultRef } : {}),
+        documentRevision: r.documentRevision as number };
+}

package/src/session-launch.ts

@@ -1,3 +1,4 @@
+import { parseRoleLaunchSelection, type RoleLaunchSelection } from './role-launch'
 /**
  * session-launch — how a session was launched: provider, model and thinking
  * level, and WHERE each value came from.
@@ -35,11 +36,14 @@ export const MODEL_AXIS_SOURCES = [
     'user',
     /** The dashboard dialog restored it from the last launch (browser-local memory). */
     'remembered',
+    /** The authoritative daemon role default or host project override. */
+    'stored_default',
+    'project_default',
     /** A mesh capability slot supplied it (or a difficulty preset the slot outranked). */
     'mesh_slot',
     /** An explicit per-task model / thinking level on a mesh queue task. */
     'task_override',
-    /** Nothing was requested; the provider's default is known (discovery / manifest). */
+    /** Nothing requested: the provider chooses; resolvedDefault records it when known. */
     'provider_default',
     /** A value was requested without saying where it came from, or nothing is known. */
     'unspecified',
@@ -97,11 +101,19 @@ export interface ModelSelection {
     /** Last value the provider itself reported (statusline, native history). */
     observed?: string
     observedAt?: number
+    /**
+     * The provider SILENTLY substituted another model for the requested one
+     * (antigravity: `model X is not recognized … Using "Y" instead`). `observed`
+     * then holds the model actually running. P2P/launch-record only — the
+     * server path never carries it (see the content boundary above).
+     */
+    fallback?: boolean
     /** Every value change in order. The last entry is the value in force. */
     history: ModelSelectionHistoryEntry[]
 }
 
 export interface SessionLaunchRecord {
+    roleLaunch?: RoleLaunchSelection
     sessionId: string
     providerType: string
     providerVersion?: string
@@ -201,6 +213,7 @@ function parseModelSelection(raw: unknown): ModelSelection | undefined {
     const current = readString(record.current)
     const observed = readString(record.observed)
     const observedAt = readFiniteNumber(record.observedAt)
+    const fallback = record.fallback === true
     return {
         source: isModelAxisSource(record.source) ? record.source : 'unspecified',
         ...(requested ? { requested } : {}),
@@ -209,6 +222,7 @@ function parseModelSelection(raw: unknown): ModelSelection | undefined {
         ...(current ? { current } : {}),
         ...(observed ? { observed } : {}),
         ...(observedAt !== undefined ? { observedAt } : {}),
+        ...(fallback ? { fallback } : {}),
         history: history.slice(-MODEL_SELECTION_HISTORY_LIMIT),
     }
 }
@@ -230,7 +244,9 @@ export function parseSessionLaunchRecord(raw: unknown): SessionLaunchRecord | un
     const providerVersion = readString(record.providerVersion)
     const workspace = readString(record.workspace)
     const autoApproveModeId = readString(record.autoApproveModeId)
+    const roleLaunch = parseRoleLaunchSelection(record.roleLaunch)
     return {
+        ...(roleLaunch ? { roleLaunch } : {}),
         sessionId,
         providerType,
         ...(providerVersion ? { providerVersion } : {}),

package/src/slot-proposal.ts

@@ -40,6 +40,13 @@ import {
 export interface CliSlotRecipe {
     /** Optional model to pin on the slot. Best-effort at launch. */
     model?: string
+    /**
+     * Optional ordered candidate models to prefer when the provider's live
+     * `modelOptions` (from model discovery) is present on `DetectedCliProvider`.
+     * The first candidate present in `modelOptions` wins; falls back to `model`
+     * when `modelOptions` is absent or contains none of the candidates.
+     */
+    modelCandidates?: readonly string[]
     /** Optional thinking level, in the provider's own vocabulary. */
     thinkingLevel?: string
     /** Difficulty range this slot handles. Empty = general-purpose. */
@@ -101,11 +108,26 @@ export const CLI_SLOT_RECIPES: Readonly<Record<string, readonly CliSlotRecipe[]>
     ],
     'antigravity-cli': [
         {
-            model: 'Gemini 3.1 Pro (High)',
+            model: 'Gemini 3.8 Flash (High)',
+            modelCandidates: ['Gemini 3.8 Flash (High)', 'Gemini 4 Argon (Low)', 'Gemini 3.7 Flash (High)', 'Gemini 3.1 Pro (High)'],
             difficulty: ['easy'],
             maxParallel: 2,
             rationale: 'Cheap capacity for easy tasks.',
         },
+        {
+            model: 'Gemini 4 Argon (Medium)',
+            modelCandidates: ['Gemini 4 Argon (Medium)', 'Gemini 3.8 Flash (High)', 'Gemini 3.7 Flash (High)', 'Gemini 3.1 Pro (High)'],
+            difficulty: ['medium'],
+            maxParallel: 2,
+            rationale: 'Balanced Argon tier for medium tasks.',
+        },
+        {
+            model: 'Gemini 4 Argon (High)',
+            modelCandidates: ['Gemini 4 Argon (High)', 'Gemini 3.8 Flash (High)', 'Gemini 3.1 Pro (High)'],
+            difficulty: ['difficult'],
+            maxParallel: 1,
+            rationale: 'Reserved for hard tasks; capped at 1 to bound cost.',
+        },
     ],
     'cursor-cli': [
         {
@@ -137,6 +159,13 @@ export interface DetectedCliProvider {
     displayName?: string
     /** Detected version, when known. Display only — never affects the mapping. */
     version?: string
+    /**
+     * Live discovered / resolved `modelOptions` for this provider on the node,
+     * when available on the status catalog. When present and non-empty, recipes
+     * prefer the first matching model from `[recipe.model, ...recipe.modelCandidates]`
+     * that exists in `modelOptions`.
+     */
+    modelOptions?: readonly string[]
 }
 
 /** One proposed slot plus why it was proposed. */
@@ -197,6 +226,36 @@ function dedupeDetected(detected: readonly DetectedCliProvider[]): DetectedCliPr
     return out
 }
 
+/**
+ * Resolve a recipe's pinned model against the provider's live `modelOptions`
+ * (populated from the daemon's model-discovery overlay when available). If
+ * `modelOptions` is absent or none of the recipe's candidates appear in it,
+ * falls back to `recipe.model`.
+ */
+function resolveRecipeModel(
+    recipe: CliSlotRecipe,
+    modelOptions: readonly string[] | undefined,
+): string | undefined {
+    if (!Array.isArray(modelOptions) || modelOptions.length === 0) {
+        return recipe.model
+    }
+    const available = new Set(
+        modelOptions
+            .filter((m): m is string => typeof m === 'string' && m.trim().length > 0)
+            .map(m => m.trim()),
+    )
+    if (available.size === 0) return recipe.model
+    const candidates = [
+        ...(recipe.model ? [recipe.model] : []),
+        ...(recipe.modelCandidates ?? []),
+    ]
+    for (const candidate of candidates) {
+        const trimmed = typeof candidate === 'string' ? candidate.trim() : ''
+        if (trimmed && available.has(trimmed)) return trimmed
+    }
+    return recipe.model
+}
+
 /**
  * Build a capability-slot proposal from a node's detected CLI providers.
  *
@@ -229,7 +288,7 @@ export function buildSlotProposal(
             // a proposal can never preview a shape the write would reshape.
             const slot = normalizeNodeCapabilitySlot({
                 provider: provider.type,
-                model: recipe.model,
+                model: resolveRecipeModel(recipe, provider.modelOptions),
                 thinkingLevel: recipe.thinkingLevel,
                 difficulty: recipe.difficulty,
                 maxParallel: recipe.maxParallel,

package/src/task-source-phase.ts

@@ -0,0 +1,61 @@
+import type { OwnedPathEntry } from './path-ownership'
+
+export type MeshTaskPhase = 'source' | 'integration'
+
+/** Host-produced evidence. Never accepted from MCP/peer-supplied paths or branch labels. */
+export interface PhysicalOwnershipScope {
+    version: 1
+    repoIdentity: string
+    machineId: string
+    nodeId: string
+    worktree: string
+    worktreeIdentity: string
+    gitDir: string
+    commonGitDir: string
+    phase: MeshTaskPhase
+    gitResources: { index: string; refs: string; hooks: string; config: string }
+    resources: Array<{ path: string; identity?: string; subtree: boolean }>
+    declaration: readonly OwnedPathEntry[]
+}
+
+/** A source packet is an input to integration, never release/feature acceptance. */
+export interface MeshSourceCandidate {
+    version: 1
+    readiness: 'uncommitted' | 'verified_source_candidate'
+    taskId: string
+    missionId: string
+    revision: number
+    repoIdentity: string
+    machineId: string
+    canonicalWorktree: string
+    rootBaseSha: string
+    ossBaseSha: string
+    rootCandidateSha?: string
+    ossCandidateSha?: string
+    patchSha256: string
+    manifestSha256: string
+    touchedPaths: string[]
+    tests: Array<{ command: string; exit: number; logSha256: string }>
+    settledCommands: boolean
+    integrationTaskId: string
+    logicalOverlapTaskIds: string[]
+}
+
+/** Product B consumes one frozen batch; normal hooks/parity/gates remain required. */
+export interface MeshIntegrationBatchContract {
+    version: 1
+    batchId: string
+    candidates: MeshSourceCandidate[]
+    integrationOrder: string[]
+    approvedRootSha: string
+    approvedOssSha: string
+    bundleInvocationCount: 1
+    requiredGates: string[]
+    normalHooksRequired: true
+    independentReviewRequired: true
+    ownerLandingApprovalRequired: true
+}
+
+/** These only rank legal targets; targetNodeId/SessionId and requiredTags remain hard. */
+export interface MeshRoutingPreferences { nodeIds?: string[]; providers?: string[] }
+export interface MeshReviewConstraint { sourceTaskId: string; differentProvider: true }

package/src/turn-evidence.ts

@@ -56,7 +56,11 @@ export type DeliveryOutcome = typeof DELIVERY_OUTCOMES[number]
 export const DELIVERY_VIAS = ['local', 'p2p'] as const
 export type DeliveryVia = typeof DELIVERY_VIAS[number]
 
-export const DISPATCH_FAILURE_REASONS = ['worker_absent', 'transport_error', 'spawn_failed', 'rejected_by_worker', 'timeout'] as const
+/** `submit_unconfirmed` (SUBMIT-UNCONFIRMED-RECLAIM): the worker's CLI never
+ *  took the written prompt — the submit budget and one re-paste were spent at
+ *  an idle composer. An owner daemon older than this value drops the evidence
+ *  as invalid and falls back to its consume/turn holds (the pre-fix path). */
+export const DISPATCH_FAILURE_REASONS = ['worker_absent', 'transport_error', 'spawn_failed', 'rejected_by_worker', 'timeout', 'submit_unconfirmed'] as const
 export type DispatchFailureReason = typeof DISPATCH_FAILURE_REASONS[number]
 
 /**
@@ -83,9 +87,9 @@ export type SessionReboundReason = typeof SESSION_REBOUND_REASONS[number]
 
 export const SUSPENSION_MODALS = ['approval', 'choice'] as const
 export type SuspensionModal = typeof SUSPENSION_MODALS[number]
-export const SUSPENSION_RESOLUTIONS = ['approved', 'rejected', 'answered'] as const
+export const SUSPENSION_RESOLUTIONS = ['approved', 'rejected', 'answered', 'dismissed'] as const
 export type SuspensionResolution = typeof SUSPENSION_RESOLUTIONS[number]
-export const SUSPENSION_RESOLUTION_VIAS = ['modal_button', 'auto_approve', 'prompt_answer'] as const
+export const SUSPENSION_RESOLUTION_VIAS = ['modal_button', 'auto_approve', 'prompt_answer', 'modal_disappeared'] as const
 export type SuspensionResolutionVia = typeof SUSPENSION_RESOLUTION_VIAS[number]
 
 export const TURN_END_STRENGTHS = ['genuine', 'weak'] as const
@@ -97,13 +101,13 @@ export const TURN_END_BLOCK_REASONS = [
 ] as const
 export type TurnEndBlockReason = typeof TURN_END_BLOCK_REASONS[number]
 
-export const NATIVE_TURN_OUTCOMES = ['completed', 'aborted'] as const
+export const NATIVE_TURN_OUTCOMES = ['completed', 'aborted', 'failed'] as const
 export type NativeTurnOutcome = typeof NATIVE_TURN_OUTCOMES[number]
 
 export const LIVENESS_RESULTS = ['alive', 'unknown', 'read_failed', 'dead'] as const
 export type LivenessResult = typeof LIVENESS_RESULTS[number]
 
-export const PROVIDER_FAILURES = ['auth_failed', 'billing_failed'] as const
+export const PROVIDER_FAILURES = ['auth_failed', 'billing_failed', 'usage_limit_exceeded', 'server_overloaded', 'provider_error'] as const
 export type ProviderFailure = typeof PROVIDER_FAILURES[number]
 
 /**
@@ -150,11 +154,11 @@ export const HOLD_REASONS = [
     // — a turn_end commits the report (R9t), expiry commits it anyway (R13t) so
     // a session whose FSM never shows the idle edge again does not wait for
     // liveness / hard_ceiling.
-    'await_end',
+    'await_end', 'report_correction',
 ] as const
 export type HoldReason = typeof HOLD_REASONS[number]
 
-export const TURN_OUTCOMES = ['completed', 'failed', 'cancelled'] as const
+export const TURN_OUTCOMES = ['completed', 'blocked', 'failed', 'cancelled'] as const
 export type TurnOutcome = typeof TURN_OUTCOMES[number]
 
 export const COMMIT_STRENGTHS = ['genuine', 'weak', 'tool_report', 'operator'] as const
@@ -164,7 +168,7 @@ export type CommitStrength = typeof COMMIT_STRENGTHS[number]
 export const TURN_REASONS = [
     // commits
     'turn_end', 'weak_end_confirmed', 'transcript_final', 'worker_reported',
-    'finalization_timeout_no_response', 'session_error', 'provider_auth_failed', 'provider_billing_failed',
+    'finalization_timeout_no_response', 'weak_end_liveness_unconfirmed', 'weak_end_probe_unobserved', 'report_correction_expired', 'session_error', 'provider_auth_failed', 'provider_billing_failed', 'provider_usage_limit_exceeded', 'provider_server_overloaded', 'provider_error',
     'operator_cancel', 'intentional_cleanup', 'task_removed', 'mission_abandoned', 'superseded',
     'operator_update', 'refine_terminal', 'validation_terminal',
     'hard_ceiling', 'reclaim_budget_exhausted', 'hollow_max_retries', 'migration_orphan',
@@ -186,7 +190,7 @@ export type TurnReason = typeof TURN_REASONS[number]
  * owner's local `turn_events.payload_json` and is rendered at deliver time.
  */
 export const NOTIFY_KINDS = [
-    'completed', 'failed', 'cancelled', 'stopped', 'approval', 'choice', 'approval_resolved',
+    'completed', 'blocked', 'failed', 'cancelled', 'stopped', 'approval', 'choice', 'approval_resolved',
     'candidate', 'no_progress', 'progress', 'late_completion', 'mesh_event',
 ] as const
 export type NotifyKind = typeof NOTIFY_KINDS[number]
@@ -207,7 +211,7 @@ export interface LiveTurnPending { modal: boolean; adapterPending: boolean; trai
 /** Structural copy of daemon-core's `CoordinatorIdentity` (this package cannot import daemon-core). */
 export interface EvidenceCoordinatorIdentity { daemonId: string; coordinatorRunId: string; sessionId?: string }
 
-export interface NativeTurnMarkerRef { outcome: NativeTurnOutcome; turnId?: string }
+export interface NativeTurnMarkerRef { outcome: NativeTurnOutcome; turnId?: string; receivedAt?: number; startedAt?: number; errorAt?: number }
 
 export interface EvidenceEnvelope {
     /** Stable id of this observation; dedupe key across republish/replication. */
@@ -250,10 +254,10 @@ export type TurnEvidenceBody =
     | { kind: 'session_rebound'; toSessionId: string; reason: SessionReboundReason }
     // ── worker turn lifecycle ──
     | { kind: 'turn_started'; retro: boolean }
-    | { kind: 'suspension'; modal: SuspensionModal; modalKey?: string }
-    | { kind: 'suspension_resolved'; resolution: SuspensionResolution; via: SuspensionResolutionVia }
+    | { kind: 'suspension'; modal: SuspensionModal; modalKey?: string; providerSetup?: boolean; clockUnknown?: boolean }
+    | { kind: 'suspension_resolved'; resolution: SuspensionResolution; via: SuspensionResolutionVia; modalKey?: string }
     | { kind: 'turn_end'; strength: TurnEndStrength; afterFinalizationTimeout?: boolean; hollow?: boolean; summary?: SummaryRef
-        blockReason?: TurnEndBlockReason; releasedByHardCap?: boolean; nativeOutcome?: NativeTurnOutcome; live?: LiveTurnPending
+        blockReason?: TurnEndBlockReason; releasedByHardCap?: boolean; nativeOutcome?: NativeTurnOutcome; nativeMarker?: NativeTurnMarkerRef; live?: LiveTurnPending
         /**
          * Stamped (true only) by the WORKER's daemon when the session holds a live
          * worker-MCP session bind, i.e. the worker can call report_completion. The
@@ -273,7 +277,7 @@ export type TurnEvidenceBody =
         live: LiveTurnPending; summary?: SummaryRef; messageAt?: number }
     | { kind: 'transcript_activity'; newestActivityAt: number }
     | { kind: 'no_progress'; stalledMs: number; observedStatus: NoProgressObservedStatus; finalAssistantPresent: boolean }
-    | { kind: 'liveness'; result: LivenessResult }
+    | { kind: 'liveness'; result: LivenessResult; probeStartedAtMs?: number }
     | { kind: 'process_exit'; exitCode: number | null; providerFailure?: ProviderFailure }
     | { kind: 'session_error'; reason: SessionErrorReason }
     // ── worker MCP (F2) ──
@@ -284,6 +288,7 @@ export type TurnEvidenceBody =
      */
     | { kind: 'worker_report'; outcome: WorkerReportOutcome; summary?: SummaryRef; hasHandoffNotes: boolean
         branchState?: WorkerBranchState; touchedFileCount?: number }
+    | { kind: 'worker_report_correction_requested'; deliveryId?: string }
     | { kind: 'worker_progress'; note?: SummaryRef }
     // ── coordinator / operator ──
     | { kind: 'git_side_effect'; dirty: boolean; commitsSinceDispatch: number; attributable: boolean }
@@ -352,13 +357,13 @@ export const TURN_EVIDENCE_FIELD_SPECS: TurnEvidenceFieldSpecs = {
     duplicate_dispatch_refusal: { holderSessionId: id, holderAttemptId: idOpt },
     session_rebound: { toSessionId: id, reason: en(SESSION_REBOUND_REASONS) },
     turn_started: { retro: bool },
-    suspension: { modal: en(SUSPENSION_MODALS), modalKey: idOpt },
-    suspension_resolved: { resolution: en(SUSPENSION_RESOLUTIONS), via: en(SUSPENSION_RESOLUTION_VIAS) },
+    suspension: { modal: en(SUSPENSION_MODALS), modalKey: idOpt, providerSetup: boolOpt, clockUnknown: boolOpt },
+    suspension_resolved: { resolution: en(SUSPENSION_RESOLUTIONS), via: en(SUSPENSION_RESOLUTION_VIAS), modalKey: idOpt },
     turn_end: {
         strength: en(TURN_END_STRENGTHS), afterFinalizationTimeout: boolOpt, hollow: boolOpt,
         summary: { t: 'summary_ref', optional: true }, blockReason: enOpt(TURN_END_BLOCK_REASONS),
         releasedByHardCap: boolOpt, nativeOutcome: enOpt(NATIVE_TURN_OUTCOMES), live: { t: 'live', optional: true },
-        reportExpected: boolOpt, providerFailure: enOpt(PROVIDER_FAILURES),
+        nativeMarker: { t: 'native_marker', optional: true }, reportExpected: boolOpt, providerFailure: enOpt(PROVIDER_FAILURES),
     },
     transcript_final: {
         selfAttributing: bool, nativeRead: bool, nativeMarker: { t: 'native_marker', optional: true },
@@ -366,13 +371,14 @@ export const TURN_EVIDENCE_FIELD_SPECS: TurnEvidenceFieldSpecs = {
     },
     transcript_activity: { newestActivityAt: ms },
     no_progress: { stalledMs: ms, observedStatus: en(NO_PROGRESS_OBSERVED_STATUSES), finalAssistantPresent: bool },
-    liveness: { result: en(LIVENESS_RESULTS) },
+    liveness: { result: en(LIVENESS_RESULTS), probeStartedAtMs: msOpt },
     process_exit: { exitCode: { t: 'int', nullable: true }, providerFailure: enOpt(PROVIDER_FAILURES) },
     session_error: { reason: en(SESSION_ERROR_REASONS) },
     worker_report: {
         outcome: en(WORKER_REPORT_OUTCOMES), summary: { t: 'summary_ref', optional: true }, hasHandoffNotes: bool,
         branchState: enOpt(WORKER_BRANCH_STATES), touchedFileCount: intOpt,
     },
+    worker_report_correction_requested: { deliveryId: { t: 'id', optional: true } },
     worker_progress: { note: { t: 'summary_ref', optional: true } },
     git_side_effect: { dirty: bool, commitsSinceDispatch: { t: 'int' }, attributable: bool },
     cancel: { reason: en(CANCEL_REASONS) },
@@ -440,11 +446,12 @@ function isLiveTurnPending(value: unknown): value is LiveTurnPending {
         && (value.newestActivityAt === undefined || isFiniteNumber(value.newestActivityAt))
 }
 
-function isNativeMarkerRef(value: unknown): value is NativeTurnMarkerRef {
+export function isNativeMarkerRef(value: unknown): value is NativeTurnMarkerRef {
     return isRecord(value)
-        && hasOnlyKeys(value, ['outcome', 'turnId'])
+        && hasOnlyKeys(value, ['outcome', 'turnId', 'receivedAt', 'startedAt', 'errorAt'])
         && (NATIVE_TURN_OUTCOMES as readonly string[]).includes(value.outcome as string)
         && (value.turnId === undefined || isEvidenceIdentifier(value.turnId))
+        && ['receivedAt', 'startedAt', 'errorAt'].every((key) => value[key] === undefined || isFiniteNumber(value[key]))
 }
 
 function isCoordinatorIdentity(value: unknown): value is EvidenceCoordinatorIdentity {